Could be because I am certainly not an expert. My assumptions with this are as follows :

1. I dont touch the generated code
2. I need to make an impl.go of some sort to contain my own code (abiding to required signatures - input /output paramters ) that are basically dictated from the generated code
3. I need code ( I think in main.go or similar) to tie it all together by wiring gorilla mux paths to a server interface which then invokes my own supplied code.

For the "standard" non strict server implementation (which works) I did the following

1. check
2. I code my own busines logic in impl.go somewhat according like e.g the following lines for the simple invocation point

`// Readiness check van deze API
// (GET /heartbeat)
func (s Server) GetHeartbeat(w http.ResponseWriter, r *http.Request) {

s.logger.Info("hello from GetHeartbeat", "request", os.Getenv("USER"))

w.WriteHeader(http.StatusOK)

}`

The server interface in the generated code looks as follows:

`type ServerInterface interface {
// Readiness check van deze API
// (GET /heartbeat)
GetHeartbeat(w http.ResponseWriter, r *http.Request)
// Laatste wijziging
// (GET /laatsteWijziging)
GetLaatsteWijziging(w http.ResponseWriter, r *http.Request)

// (GET /openapi)
GetOpenapi(w http.ResponseWriter, r *http.Request)

// (GET /openapi.json)
GetOpenapiJson(w http.ResponseWriter, r *http.Request)
// Organisaties Collectie
// (GET /organisaties)
GetOrganisaties(w http.ResponseWriter, r *http.Request, params GetOrganisatiesParams)
// Openbare organisatie Informatie
// (GET /organisaties/{oin})
GetOrganisatiesOin(w http.ResponseWriter, r *http.Request, oin string, params GetOrganisatiesOinParams)

}`

3. In main.go I bring it all together with the following code snippet :

`r := mux.NewRouter()

// get an `http.Handler` that we can use
h := api.HandlerFromMux(server, r)

s := &http.Server{
	Handler: h,
	Addr:    "0.0.0.0:8080",
}

// And we serve HTTP until the world ends.
log.Fatal(s.ListenAndServe())`

Note that the "server" is an interface that contains the signatures listed in the previous point and the HandlerFromMux(server, r) is implemented in the generated code.

However things look quite different when working with a strict server implementation.

1. Check

2. I now have a StrictServerInterface which looks like follows:
   `// StrictServerInterface represents all server handlers.
   type StrictServerInterface interface {
   // Readiness check van deze API
   // (GET /heartbeat)
   GetHeartbeat(ctx context.Context, request GetHeartbeatRequestObject) (GetHeartbeatResponseObject, error)
   // Laatste wijziging
   // (GET /laatsteWijziging)
   GetLaatsteWijziging(ctx context.Context, request GetLaatsteWijzigingRequestObject) (GetLaatsteWijzigingResponseObject, error)

   // (GET /openapi)
   GetOpenapi(ctx context.Context, request GetOpenapiRequestObject) (GetOpenapiResponseObject, error)

   // (GET /openapi.json)
   GetOpenapiJson(ctx context.Context, request GetOpenapiJsonRequestObject) (GetOpenapiJsonResponseObject, error)
   // Organisaties Collectie
   // (GET /organisaties)
   GetOrganisaties(ctx context.Context, request GetOrganisatiesRequestObject) (GetOrganisatiesResponseObject, error)
   // Openbare organisatie Informatie
   // (GET /organisaties/{oin})
   GetOrganisatiesOin(ctx context.Context, request GetOrganisatiesOinRequestObject) (GetOrganisatiesOinResponseObject, error)
   }
   `
   Assuming the same procedure (maybe wrong) I can do my own implementation something like this :

/ Readiness check van deze API // (GET /heartbeat) func (Server) GetHeartbeat(ctx context.Context, request GetHeartbeatRequestObject) (GetHeartbeatResponseObject, error) { return nil, nil }

for this method (and the rest) it satisfies the StrictServerInterface which I think is needed ?

3. The main.go however faces a problem now
   `server := api.NewServer()

   r := mux.NewRouter()

   // get an http.Handler that we can use
   h := api.HandlerFromMux(server, r)

   s := &http.Server{
   Handler: h,
   Addr: "0.0.0.0:8080",
   }

   // And we serve HTTP until the world ends.
   log.Fatal(s.ListenAndServe())`

The server that I create has the methods (signatures) as listed in point 2 but I cant use the "HandlerFromMux(server, r)
" call (provided from the generated code) like in the above main.go code anymore because the server that needs to be supplied there is not the strict one ( StrictServerInterface) but the "ServerInterface" one which has the "simple" signature (w http.ResponseWriter, r *http.Request). So obviously I get a compile error. Also I cant find anything similar in the generated code I can use as a replacement so I am stuck.

The question then is is my approach for the strict server (as listed under 2) valid and if so what do I have to do in the main.go code to tie it all together.
Hope this clarifies things somewhat

Kind Regards Peter