remove secondary codegen

14 files changed, 511 insertions, 245 deletions

diff --git a/internal/tui/tui.go b/internal/tui/tui.go
index 0bda5facb..dbb8460ed 100644
--- a/internal/tui/tui.go
+++ b/internal/tui/tui.go
@@ -267,15 +267,15 @@ func (a appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 
 	// Handle SSE events from the TypeScript backend
-	case *client.EventStorageWrite:
-		slog.Debug("Received SSE event", "key", msg.Key)
+	case client.EventStorageWrite:
+		slog.Debug("Received SSE event", "key", msg.Properties.Key)
 
-		splits := strings.Split(msg.Key, "/")
+		splits := strings.Split(msg.Properties.Key, "/")
 		current := a.app.State
 
 		for i, part := range splits {
 			if i == len(splits)-1 {
-				current[part] = msg.Content
+				current[part] = msg.Properties.Content
 			} else {
 				if _, exists := current[part]; !exists {
 					current[part] = make(map[string]any)
diff --git a/js/src/bus/index.ts b/js/src/bus/index.ts
index 15d2b1107..cf5101b67 100644
--- a/js/src/bus/index.ts
+++ b/js/src/bus/index.ts
@@ -1,4 +1,4 @@
-import { z, type ZodType } from "zod/v4";
+import { z, type ZodType } from "zod";
 import { App } from "../app";
 import { Log } from "../util/log";
 
@@ -30,16 +30,23 @@ export namespace Bus {
     return result;
   }
 
-  export function specs() {
-    const children = {} as any;
-    for (const [type, def] of registry.entries()) {
-      children["event." + def.type] = def.properties;
-    }
-    const result = z.toJSONSchema(z.object(children)) as any;
-    result.definitions = result.properties;
-    delete result.properties;
-    delete result.required;
-    return result;
+  export function payloads() {
+    return z.discriminatedUnion(
+      "type",
+      registry
+        .entries()
+        .map(([type, def]) =>
+          z
+            .object({
+              type: z.literal(type),
+              properties: def.properties,
+            })
+            .openapi({
+              ref: "Event" + "." + def.type,
+            }),
+        )
+        .toArray() as any,
+    );
   }
 
   export function publish<Definition extends EventDefinition>(
diff --git a/js/src/index.ts b/js/src/index.ts
index 380ea64cd..ddea15e91 100644
--- a/js/src/index.ts
+++ b/js/src/index.ts
@@ -28,10 +28,6 @@ cli.command("generate", "Generate OpenAPI and event specs").action(async () => {
     path.join(dir, "openapi.json"),
     JSON.stringify(specs, null, 2),
   );
-  await Bun.write(
-    path.join(dir, "event.json"),
-    JSON.stringify(Bus.specs(), null, 2),
-  );
 });
 
 cli
diff --git a/js/src/lsp/client.ts b/js/src/lsp/client.ts
index fda77948a..cb8bdad2d 100644
--- a/js/src/lsp/client.ts
+++ b/js/src/lsp/client.ts
@@ -10,7 +10,7 @@ import { App } from "../app";
 import { Log } from "../util/log";
 import { LANGUAGE_EXTENSIONS } from "./language";
 import { Bus } from "../bus";
-import z from "zod/v4";
+import z from "zod";
 
 export namespace LSPClient {
   const log = Log.create({ service: "lsp.client" });
diff --git a/js/src/server/server.ts b/js/src/server/server.ts
index f56c87283..98b2cf5cb 100644
--- a/js/src/server/server.ts
+++ b/js/src/server/server.ts
@@ -43,26 +43,46 @@ export namespace Server {
           },
         }),
       )
-      .get("/event", async (c) => {
-        log.info("event connected");
-        return streamSSE(c, async (stream) => {
-          stream.writeSSE({
-            data: JSON.stringify({}),
-          });
-          const unsub = Bus.subscribeAll(async (event) => {
-            await stream.writeSSE({
-              data: JSON.stringify(event),
+      .get(
+        "/event",
+        describeRoute({
+          description: "Get events",
+          responses: {
+            200: {
+              description: "Event stream",
+              content: {
+                "application/json": {
+                  schema: resolver(
+                    Bus.payloads().openapi({
+                      ref: "Event",
+                    }),
+                  ),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          log.info("event connected");
+          return streamSSE(c, async (stream) => {
+            stream.writeSSE({
+              data: JSON.stringify({}),
             });
-          });
-          await new Promise<void>((resolve) => {
-            stream.onAbort(() => {
-              unsub();
-              resolve();
-              log.info("event disconnected");
+            const unsub = Bus.subscribeAll(async (event) => {
+              await stream.writeSSE({
+                data: JSON.stringify(event),
+              });
+            });
+            await new Promise<void>((resolve) => {
+              stream.onAbort(() => {
+                unsub();
+                resolve();
+                log.info("event disconnected");
+              });
             });
           });
-        });
-      })
+        },
+      )
       .post(
         "/session_create",
         describeRoute({
diff --git a/js/src/session/message.ts b/js/src/session/message.ts
index 91bcd19b4..c944fa640 100644
--- a/js/src/session/message.ts
+++ b/js/src/session/message.ts
@@ -1,14 +1,13 @@
 import z from "zod";
-import { z as zv4 } from "zod/v4";
 import { Bus } from "../bus";
 
 export namespace Message {
   export const Event = {
     Updated: Bus.event(
       "message.updated",
-      zv4.object({
-        sessionID: zv4.string(),
-        messageID: zv4.string(),
+      z.object({
+        sessionID: z.string(),
+        messageID: z.string(),
       }),
     ),
   };
diff --git a/js/src/session/session.ts b/js/src/session/session.ts
index a876976bd..1cf89de19 100644
--- a/js/src/session/session.ts
+++ b/js/src/session/session.ts
@@ -11,7 +11,6 @@ import {
   streamText,
 } from "ai";
 import { z } from "zod";
-import { z as zv4 } from "zod/v4";
 import * as tools from "../tool";
 import { Decimal } from "decimal.js";
 
@@ -35,8 +34,8 @@ export namespace Session {
   export const Event = {
     Updated: Bus.event(
       "session.updated",
-      zv4.object({
-        sessionID: zv4.string(),
+      z.object({
+        sessionID: z.string(),
       }),
     ),
   };
diff --git a/js/src/storage/storage.ts b/js/src/storage/storage.ts
index 3b4c63cb8..85fa26be6 100644
--- a/js/src/storage/storage.ts
+++ b/js/src/storage/storage.ts
@@ -5,7 +5,7 @@ import { Log } from "../util/log";
 import { App } from "../app";
 import { AppPath } from "../app/path";
 import { Bus } from "../bus";
-import z from "zod/v4";
+import z from "zod";
 
 export namespace Storage {
   const log = Log.create({ service: "storage" });
diff --git a/pkg/client/client.go b/pkg/client/client.go
index fba38c008..bf2d5038e 100644
--- a/pkg/client/client.go
+++ b/pkg/client/client.go
@@ -2,4 +2,3 @@ package client
 
 //go:generate bun run ../../js/src/index.ts generate
 //go:generate go tool github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --package=client --generate=types,client,models -o generated-client.go ./gen/openapi.json
-//go:generate go tool github.com/atombender/go-jsonschema -p client -o generated-event.go ./gen/event.json
diff --git a/pkg/client/event.go b/pkg/client/event.go
index a43c4c8ea..f5aab2d26 100644
--- a/pkg/client/event.go
+++ b/pkg/client/event.go
@@ -5,21 +5,9 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
-	"reflect"
 	"strings"
 )
 
-var EventMap = map[string]any{
-	"storage.write":   EventStorageWrite{},
-	"session.updated": EventSessionUpdated{},
-	"message.updated": EventMessageUpdated{},
-}
-
-type EventMessage struct {
-	Type       string          `json:"type"`
-	Properties json.RawMessage `json:"properties"`
-}
-
 func (c *Client) Event(ctx context.Context) (<-chan any, error) {
 	events := make(chan any)
 	req, err := http.NewRequestWithContext(ctx, "GET", c.Server+"event", nil)
@@ -42,24 +30,18 @@ func (c *Client) Event(ctx context.Context) (<-chan any, error) {
 			if strings.HasPrefix(line, "data: ") {
 				data := strings.TrimPrefix(line, "data: ")
 
-				var eventMsg EventMessage
-				if err := json.Unmarshal([]byte(data), &eventMsg); err != nil {
+				var event Event
+				if err := json.Unmarshal([]byte(data), &event); err != nil {
 					continue
 				}
 
-				eventTemplate, exists := EventMap[eventMsg.Type]
-				if !exists {
-					continue
-				}
-
-				eventValue := reflect.New(reflect.TypeOf(eventTemplate)).Interface()
-
-				if err := json.Unmarshal(eventMsg.Properties, eventValue); err != nil {
+				val, err := event.ValueByDiscriminator()
+				if err != nil {
 					continue
 				}
 
 				select {
-				case events <- eventValue:
+				case events <- val:
 				case <-ctx.Done():
 					return
 				}
diff --git a/pkg/client/gen/event.json b/pkg/client/gen/event.json
deleted file mode 100644
index e40f1308f..000000000
--- a/pkg/client/gen/event.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
-  "type": "object",
-  "$schema": "https://json-schema.org/draft-2020-12/schema",
-  "definitions": {
-    "event.storage.write": {
-      "type": "object",
-      "properties": {
-        "key": {
-          "type": "string"
-        },
-        "content": {}
-      },
-      "required": [
-        "key",
-        "content"
-      ]
-    },
-    "event.lsp.client.diagnostics": {
-      "type": "object",
-      "properties": {
-        "serverID": {
-          "type": "string"
-        },
-        "path": {
-          "type": "string"
-        }
-      },
-      "required": [
-        "serverID",
-        "path"
-      ]
-    },
-    "event.message.updated": {
-      "type": "object",
-      "properties": {
-        "sessionID": {
-          "type": "string"
-        },
-        "messageID": {
-          "type": "string"
-        }
-      },
-      "required": [
-        "sessionID",
-        "messageID"
-      ]
-    },
-    "event.session.updated": {
-      "type": "object",
-      "properties": {
-        "sessionID": {
-          "type": "string"
-        }
-      },
-      "required": [
-        "sessionID"
-      ]
-    }
-  }
-}
\ No newline at end of file
diff --git a/pkg/client/gen/openapi.json b/pkg/client/gen/openapi.json
index 395ff5614..5356042c4 100644
--- a/pkg/client/gen/openapi.json
+++ b/pkg/client/gen/openapi.json
@@ -6,6 +6,25 @@
     "version": "1.0.0"
   },
   "paths": {
+    "/event": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Event stream",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Event"
+                }
+              }
+            }
+          }
+        },
+        "operationId": "getEvent",
+        "parameters": [],
+        "description": "Get events"
+      }
+    },
     "/session_create": {
       "post": {
         "responses": {
@@ -250,6 +269,136 @@
   },
   "components": {
     "schemas": {
+      "Event": {
+        "oneOf": [
+          {
+            "$ref": "#/components/schemas/Event.storage.write"
+          },
+          {
+            "$ref": "#/components/schemas/Event.lsp.client.diagnostics"
+          },
+          {
+            "$ref": "#/components/schemas/Event.message.updated"
+          },
+          {
+            "$ref": "#/components/schemas/Event.session.updated"
+          }
+        ],
+        "discriminator": {
+          "propertyName": "type",
+          "mapping": {
+            "storage.write": "#/components/schemas/Event.storage.write",
+            "lsp.client.diagnostics": "#/components/schemas/Event.lsp.client.diagnostics",
+            "message.updated": "#/components/schemas/Event.message.updated",
+            "session.updated": "#/components/schemas/Event.session.updated"
+          }
+        }
+      },
+      "Event.storage.write": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "storage.write"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "key": {
+                "type": "string"
+              },
+              "content": {}
+            },
+            "required": [
+              "key"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
+      "Event.lsp.client.diagnostics": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "lsp.client.diagnostics"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "serverID": {
+                "type": "string"
+              },
+              "path": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "serverID",
+              "path"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
+      "Event.message.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "message.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string"
+              },
+              "messageID": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "sessionID",
+              "messageID"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
+      "Event.session.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "session.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "sessionID"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
       "Session.Info": {
         "type": "object",
         "properties": {
diff --git a/pkg/client/generated-client.go b/pkg/client/generated-client.go
index 5901cb1c0..70a911908 100644
--- a/pkg/client/generated-client.go
+++ b/pkg/client/generated-client.go
@@ -24,6 +24,46 @@ const (
 	User      MessageInfoRole = "user"
 )
 
+// Event defines model for Event.
+type Event struct {
+	union json.RawMessage
+}
+
+// EventLspClientDiagnostics defines model for Event.lsp.client.diagnostics.
+type EventLspClientDiagnostics struct {
+	Properties struct {
+		Path     string `json:"path"`
+		ServerID string `json:"serverID"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
+// EventMessageUpdated defines model for Event.message.updated.
+type EventMessageUpdated struct {
+	Properties struct {
+		MessageID string `json:"messageID"`
+		SessionID string `json:"sessionID"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
+// EventSessionUpdated defines model for Event.session.updated.
+type EventSessionUpdated struct {
+	Properties struct {
+		SessionID string `json:"sessionID"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
+// EventStorageWrite defines model for Event.storage.write.
+type EventStorageWrite struct {
+	Properties struct {
+		Content *interface{} `json:"content,omitempty"`
+		Key     string       `json:"key"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
 // MessageInfo defines model for Message.Info.
 type MessageInfo struct {
 	Id       string `json:"id"`
@@ -191,6 +231,155 @@ type PostSessionMessagesJSONRequestBody PostSessionMessagesJSONBody
 // PostSessionShareJSONRequestBody defines body for PostSessionShare for application/json ContentType.
 type PostSessionShareJSONRequestBody PostSessionShareJSONBody
 
+// AsEventStorageWrite returns the union data inside the Event as a EventStorageWrite
+func (t Event) AsEventStorageWrite() (EventStorageWrite, error) {
+	var body EventStorageWrite
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventStorageWrite overwrites any union data inside the Event as the provided EventStorageWrite
+func (t *Event) FromEventStorageWrite(v EventStorageWrite) error {
+	v.Type = "storage.write"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventStorageWrite performs a merge with any union data inside the Event, using the provided EventStorageWrite
+func (t *Event) MergeEventStorageWrite(v EventStorageWrite) error {
+	v.Type = "storage.write"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsEventLspClientDiagnostics returns the union data inside the Event as a EventLspClientDiagnostics
+func (t Event) AsEventLspClientDiagnostics() (EventLspClientDiagnostics, error) {
+	var body EventLspClientDiagnostics
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventLspClientDiagnostics overwrites any union data inside the Event as the provided EventLspClientDiagnostics
+func (t *Event) FromEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
+	v.Type = "lsp.client.diagnostics"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventLspClientDiagnostics performs a merge with any union data inside the Event, using the provided EventLspClientDiagnostics
+func (t *Event) MergeEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
+	v.Type = "lsp.client.diagnostics"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsEventMessageUpdated returns the union data inside the Event as a EventMessageUpdated
+func (t Event) AsEventMessageUpdated() (EventMessageUpdated, error) {
+	var body EventMessageUpdated
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventMessageUpdated overwrites any union data inside the Event as the provided EventMessageUpdated
+func (t *Event) FromEventMessageUpdated(v EventMessageUpdated) error {
+	v.Type = "message.updated"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventMessageUpdated performs a merge with any union data inside the Event, using the provided EventMessageUpdated
+func (t *Event) MergeEventMessageUpdated(v EventMessageUpdated) error {
+	v.Type = "message.updated"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsEventSessionUpdated returns the union data inside the Event as a EventSessionUpdated
+func (t Event) AsEventSessionUpdated() (EventSessionUpdated, error) {
+	var body EventSessionUpdated
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventSessionUpdated overwrites any union data inside the Event as the provided EventSessionUpdated
+func (t *Event) FromEventSessionUpdated(v EventSessionUpdated) error {
+	v.Type = "session.updated"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventSessionUpdated performs a merge with any union data inside the Event, using the provided EventSessionUpdated
+func (t *Event) MergeEventSessionUpdated(v EventSessionUpdated) error {
+	v.Type = "session.updated"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+func (t Event) Discriminator() (string, error) {
+	var discriminator struct {
+		Discriminator string `json:"type"`
+	}
+	err := json.Unmarshal(t.union, &discriminator)
+	return discriminator.Discriminator, err
+}
+
+func (t Event) ValueByDiscriminator() (interface{}, error) {
+	discriminator, err := t.Discriminator()
+	if err != nil {
+		return nil, err
+	}
+	switch discriminator {
+	case "lsp.client.diagnostics":
+		return t.AsEventLspClientDiagnostics()
+	case "message.updated":
+		return t.AsEventMessageUpdated()
+	case "session.updated":
+		return t.AsEventSessionUpdated()
+	case "storage.write":
+		return t.AsEventStorageWrite()
+	default:
+		return nil, errors.New("unknown discriminator value: " + discriminator)
+	}
+}
+
+func (t Event) MarshalJSON() ([]byte, error) {
+	b, err := t.union.MarshalJSON()
+	return b, err
+}
+
+func (t *Event) UnmarshalJSON(b []byte) error {
+	err := t.union.UnmarshalJSON(b)
+	return err
+}
+
 // AsMessagePartText returns the union data inside the MessagePart as a MessagePartText
 func (t MessagePart) AsMessagePartText() (MessagePartText, error) {
 	var body MessagePartText
@@ -592,6 +781,9 @@ func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
 
 // The interface specification for the client above.
 type ClientInterface interface {
+	// GetEvent request
+	GetEvent(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
+
 	// PostProviderList request
 	PostProviderList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
 
@@ -622,6 +814,18 @@ type ClientInterface interface {
 	PostSessionShare(ctx context.Context, body PostSessionShareJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 }
 
+func (c *Client) GetEvent(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewGetEventRequest(c.Server)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
 func (c *Client) PostProviderList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
 	req, err := NewPostProviderListRequest(c.Server)
 	if err != nil {
@@ -754,6 +958,33 @@ func (c *Client) PostSessionShare(ctx context.Context, body PostSessionShareJSON
 	return c.Client.Do(req)
 }
 
+// NewGetEventRequest generates requests for GetEvent
+func NewGetEventRequest(server string) (*http.Request, error) {
+	var err error
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/event")
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
 // NewPostProviderListRequest generates requests for PostProviderList
 func NewPostProviderListRequest(server string) (*http.Request, error) {
 	var err error
@@ -1038,6 +1269,9 @@ func WithBaseURL(baseURL string) ClientOption {
 
 // ClientWithResponsesInterface is the interface specification for the client with responses above.
 type ClientWithResponsesInterface interface {
+	// GetEventWithResponse request
+	GetEventWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetEventResponse, error)
+
 	// PostProviderListWithResponse request
 	PostProviderListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostProviderListResponse, error)
 
@@ -1068,6 +1302,28 @@ type ClientWithResponsesInterface interface {
 	PostSessionShareWithResponse(ctx context.Context, body PostSessionShareJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionShareResponse, error)
 }
 
+type GetEventResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON200      *Event
+}
+
+// Status returns HTTPResponse.Status
+func (r GetEventResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r GetEventResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
 type PostProviderListResponse struct {
 	Body         []byte
 	HTTPResponse *http.Response
@@ -1226,6 +1482,15 @@ func (r PostSessionShareResponse) StatusCode() int {
 	return 0
 }
 
+// GetEventWithResponse request returning *GetEventResponse
+func (c *ClientWithResponses) GetEventWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetEventResponse, error) {
+	rsp, err := c.GetEvent(ctx, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParseGetEventResponse(rsp)
+}
+
 // PostProviderListWithResponse request returning *PostProviderListResponse
 func (c *ClientWithResponses) PostProviderListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostProviderListResponse, error) {
 	rsp, err := c.PostProviderList(ctx, reqEditors...)
@@ -1321,6 +1586,32 @@ func (c *ClientWithResponses) PostSessionShareWithResponse(ctx context.Context,
 	return ParsePostSessionShareResponse(rsp)
 }
 
+// ParseGetEventResponse parses an HTTP response from a GetEventWithResponse call
+func ParseGetEventResponse(rsp *http.Response) (*GetEventResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &GetEventResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest Event
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
+	}
+
+	return response, nil
+}
+
 // ParsePostProviderListResponse parses an HTTP response from a PostProviderListWithResponse call
 func ParsePostProviderListResponse(rsp *http.Response) (*PostProviderListResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
diff --git a/pkg/client/generated-event.go b/pkg/client/generated-event.go
deleted file mode 100644
index 12485b648..000000000
--- a/pkg/client/generated-event.go
+++ /dev/null
@@ -1,116 +0,0 @@
-// Code generated by github.com/atombender/go-jsonschema, DO NOT EDIT.
-
-package client
-
-import "encoding/json"
-import "fmt"
-
-type EventLspClientDiagnostics struct {
-	// Path corresponds to the JSON schema field "path".
-	Path string `json:"path" yaml:"path" mapstructure:"path"`
-
-	// ServerID corresponds to the JSON schema field "serverID".
-	ServerID string `json:"serverID" yaml:"serverID" mapstructure:"serverID"`
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (j *EventLspClientDiagnostics) UnmarshalJSON(value []byte) error {
-	var raw map[string]interface{}
-	if err := json.Unmarshal(value, &raw); err != nil {
-		return err
-	}
-	if _, ok := raw["path"]; raw != nil && !ok {
-		return fmt.Errorf("field path in EventLspClientDiagnostics: required")
-	}
-	if _, ok := raw["serverID"]; raw != nil && !ok {
-		return fmt.Errorf("field serverID in EventLspClientDiagnostics: required")
-	}
-	type Plain EventLspClientDiagnostics
-	var plain Plain
-	if err := json.Unmarshal(value, &plain); err != nil {
-		return err
-	}
-	*j = EventLspClientDiagnostics(plain)
-	return nil
-}
-
-type EventMessageUpdated struct {
-	// MessageID corresponds to the JSON schema field "messageID".
-	MessageID string `json:"messageID" yaml:"messageID" mapstructure:"messageID"`
-
-	// SessionID corresponds to the JSON schema field "sessionID".
-	SessionID string `json:"sessionID" yaml:"sessionID" mapstructure:"sessionID"`
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (j *EventMessageUpdated) UnmarshalJSON(value []byte) error {
-	var raw map[string]interface{}
-	if err := json.Unmarshal(value, &raw); err != nil {
-		return err
-	}
-	if _, ok := raw["messageID"]; raw != nil && !ok {
-		return fmt.Errorf("field messageID in EventMessageUpdated: required")
-	}
-	if _, ok := raw["sessionID"]; raw != nil && !ok {
-		return fmt.Errorf("field sessionID in EventMessageUpdated: required")
-	}
-	type Plain EventMessageUpdated
-	var plain Plain
-	if err := json.Unmarshal(value, &plain); err != nil {
-		return err
-	}
-	*j = EventMessageUpdated(plain)
-	return nil
-}
-
-type EventSessionUpdated struct {
-	// SessionID corresponds to the JSON schema field "sessionID".
-	SessionID string `json:"sessionID" yaml:"sessionID" mapstructure:"sessionID"`
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (j *EventSessionUpdated) UnmarshalJSON(value []byte) error {
-	var raw map[string]interface{}
-	if err := json.Unmarshal(value, &raw); err != nil {
-		return err
-	}
-	if _, ok := raw["sessionID"]; raw != nil && !ok {
-		return fmt.Errorf("field sessionID in EventSessionUpdated: required")
-	}
-	type Plain EventSessionUpdated
-	var plain Plain
-	if err := json.Unmarshal(value, &plain); err != nil {
-		return err
-	}
-	*j = EventSessionUpdated(plain)
-	return nil
-}
-
-type EventStorageWrite struct {
-	// Content corresponds to the JSON schema field "content".
-	Content interface{} `json:"content" yaml:"content" mapstructure:"content"`
-
-	// Key corresponds to the JSON schema field "key".
-	Key string `json:"key" yaml:"key" mapstructure:"key"`
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (j *EventStorageWrite) UnmarshalJSON(value []byte) error {
-	var raw map[string]interface{}
-	if err := json.Unmarshal(value, &raw); err != nil {
-		return err
-	}
-	if _, ok := raw["content"]; raw != nil && !ok {
-		return fmt.Errorf("field content in EventStorageWrite: required")
-	}
-	if _, ok := raw["key"]; raw != nil && !ok {
-		return fmt.Errorf("field key in EventStorageWrite: required")
-	}
-	type Plain EventStorageWrite
-	var plain Plain
-	if err := json.Unmarshal(value, &plain); err != nil {
-		return err
-	}
-	*j = EventStorageWrite(plain)
-	return nil
-}