kod_gen.go

// Code generated by "kod generate". DO NOT EDIT.
//go:build !ignoreKodGen

package case1

import (
	"context"
	"github.com/gin-gonic/gin"
	"github.com/go-kod/kod"
	"github.com/go-kod/kod/interceptor"
	"github.com/labstack/echo/v4"
	"net/http"
	"reflect"
)

// Full method names for components.
const (
	// testService_Foo_FullMethodName is the full name of the method [serviceImpl.Foo].
	testService_Foo_FullMethodName = "github.com/go-kod/kod/tests/case1/testService.Foo"
	// testRepository_Foo_FullMethodName is the full name of the method [modelImpl.Foo].
	testRepository_Foo_FullMethodName = "github.com/go-kod/kod/tests/case1/testRepository.Foo"
	// Test1Component_Foo_FullMethodName is the full name of the method [test1Component.Foo].
	Test1Component_Foo_FullMethodName = "github.com/go-kod/kod/tests/case1/Test1Component.Foo"
	// ctxInterface_Foo_FullMethodName is the full name of the method [ctxImpl.Foo].
	ctxInterface_Foo_FullMethodName = "github.com/go-kod/kod/tests/case1/ctxInterface.Foo"
	// InterceptorRetry_TestError_FullMethodName is the full name of the method [interceptorRetry.TestError].
	InterceptorRetry_TestError_FullMethodName = "github.com/go-kod/kod/tests/case1/InterceptorRetry.TestError"
	// InterceptorRetry_TestNormal_FullMethodName is the full name of the method [interceptorRetry.TestNormal].
	InterceptorRetry_TestNormal_FullMethodName = "github.com/go-kod/kod/tests/case1/InterceptorRetry.TestNormal"
	// LazyInitImpl_Try_FullMethodName is the full name of the method [lazyInitImpl.Try].
	LazyInitImpl_Try_FullMethodName = "github.com/go-kod/kod/tests/case1/LazyInitImpl.Try"
	// LazyInitComponent_Try_FullMethodName is the full name of the method [lazyInitComponent.Try].
	LazyInitComponent_Try_FullMethodName = "github.com/go-kod/kod/tests/case1/LazyInitComponent.Try"
	// panicCaseInterface_TestPanic_FullMethodName is the full name of the method [panicCase.TestPanic].
	panicCaseInterface_TestPanic_FullMethodName = "github.com/go-kod/kod/tests/case1/panicCaseInterface.TestPanic"
	// panicNoRecvoeryCaseInterface_TestPanic_FullMethodName is the full name of the method [panicNoRecvoeryCase.TestPanic].
	panicNoRecvoeryCaseInterface_TestPanic_FullMethodName = "github.com/go-kod/kod/tests/case1/panicNoRecvoeryCaseInterface.TestPanic"
)

func init() {
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/test1Controller",
		Interface: reflect.TypeOf((*test1Controller)(nil)).Elem(),
		Impl:      reflect.TypeOf(test1ControllerImpl{}),
		Refs:      `⟦dd37e4d0:KoDeDgE:github.com/go-kod/kod/tests/case1/test1Controller→github.com/go-kod/kod/tests/case1/Test1Component⟧`,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return test1Controller_local_stub{
				impl:        info.Impl.(test1Controller),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/testService",
		Interface: reflect.TypeOf((*testService)(nil)).Elem(),
		Impl:      reflect.TypeOf(serviceImpl{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return testService_local_stub{
				impl:        info.Impl.(testService),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/testRepository",
		Interface: reflect.TypeOf((*testRepository)(nil)).Elem(),
		Impl:      reflect.TypeOf(modelImpl{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return testRepository_local_stub{
				impl:        info.Impl.(testRepository),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/Test1Component",
		Interface: reflect.TypeOf((*Test1Component)(nil)).Elem(),
		Impl:      reflect.TypeOf(test1Component{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return test1Component_local_stub{
				impl:        info.Impl.(Test1Component),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/Test2Component",
		Interface: reflect.TypeOf((*Test2Component)(nil)).Elem(),
		Impl:      reflect.TypeOf(test2Component{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return test2Component_local_stub{
				impl:        info.Impl.(Test2Component),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:        "github.com/go-kod/kod/Main",
		Interface:   reflect.TypeOf((*kod.Main)(nil)).Elem(),
		Impl:        reflect.TypeOf(App{}),
		Refs:        `⟦d40a644a:KoDeDgE:github.com/go-kod/kod/Main→github.com/go-kod/kod/tests/case1/Test1Component⟧`,
		LocalStubFn: nil,
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/ctxInterface",
		Interface: reflect.TypeOf((*ctxInterface)(nil)).Elem(),
		Impl:      reflect.TypeOf(ctxImpl{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return ctxInterface_local_stub{
				impl:        info.Impl.(ctxInterface),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/test1ComponentDefaultError",
		Interface: reflect.TypeOf((*test1ComponentDefaultError)(nil)).Elem(),
		Impl:      reflect.TypeOf(test1ComponentDefaultErrorImpl{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return test1ComponentDefaultError_local_stub{
				impl:        info.Impl.(test1ComponentDefaultError),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/test1ComponentGlobalDefaultError",
		Interface: reflect.TypeOf((*test1ComponentGlobalDefaultError)(nil)).Elem(),
		Impl:      reflect.TypeOf(test1ComponentGlobalDefaultErrorImpl{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return test1ComponentGlobalDefaultError_local_stub{
				impl:        info.Impl.(test1ComponentGlobalDefaultError),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/testEchoController",
		Interface: reflect.TypeOf((*testEchoController)(nil)).Elem(),
		Impl:      reflect.TypeOf(testEchoControllerImpl{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return testEchoController_local_stub{
				impl:        info.Impl.(testEchoController),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/testGinController",
		Interface: reflect.TypeOf((*testGinController)(nil)).Elem(),
		Impl:      reflect.TypeOf(testGinControllerImpl{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return testGinController_local_stub{
				impl:        info.Impl.(testGinController),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/HTTPController",
		Interface: reflect.TypeOf((*HTTPController)(nil)).Elem(),
		Impl:      reflect.TypeOf(httpControllerImpl{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return hTTPController_local_stub{
				impl:        info.Impl.(HTTPController),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/InterceptorRetry",
		Interface: reflect.TypeOf((*InterceptorRetry)(nil)).Elem(),
		Impl:      reflect.TypeOf(interceptorRetry{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return interceptorRetry_local_stub{
				impl:        info.Impl.(InterceptorRetry),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/LazyInitImpl",
		Interface: reflect.TypeOf((*LazyInitImpl)(nil)).Elem(),
		Impl:      reflect.TypeOf(lazyInitImpl{}),
		Refs:      `⟦8e153348:KoDeDgE:github.com/go-kod/kod/tests/case1/LazyInitImpl→github.com/go-kod/kod/tests/case1/LazyInitComponent⟧`,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return lazyInitImpl_local_stub{
				impl:        info.Impl.(LazyInitImpl),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/LazyInitComponent",
		Interface: reflect.TypeOf((*LazyInitComponent)(nil)).Elem(),
		Impl:      reflect.TypeOf(lazyInitComponent{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return lazyInitComponent_local_stub{
				impl:        info.Impl.(LazyInitComponent),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/panicCaseInterface",
		Interface: reflect.TypeOf((*panicCaseInterface)(nil)).Elem(),
		Impl:      reflect.TypeOf(panicCase{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return panicCaseInterface_local_stub{
				impl:        info.Impl.(panicCaseInterface),
				interceptor: info.Interceptor,
			}
		},
	})
	kod.Register(&kod.Registration{
		Name:      "github.com/go-kod/kod/tests/case1/panicNoRecvoeryCaseInterface",
		Interface: reflect.TypeOf((*panicNoRecvoeryCaseInterface)(nil)).Elem(),
		Impl:      reflect.TypeOf(panicNoRecvoeryCase{}),
		Refs:      ``,
		LocalStubFn: func(ctx context.Context, info *kod.LocalStubFnInfo) any {
			return panicNoRecvoeryCaseInterface_local_stub{
				impl:        info.Impl.(panicNoRecvoeryCaseInterface),
				interceptor: info.Interceptor,
			}
		},
	})
}

// CodeGen version check.
var _ kod.CodeGenLatestVersion = kod.CodeGenVersion[[0][1]struct{}](`
ERROR: You generated this file with 'kod generate' (codegen
version v0.1.0). The generated code is incompatible with the version of the
github.com/go-kod/kod module that you're using. The kod module
version can be found in your go.mod file or by running the following command.

    go list -m github.com/go-kod/kod

We recommend updating the kod module and the 'kod generate' command by
running the following.

    go get github.com/go-kod/kod@latest
    go install github.com/go-kod/kod/cmd/kod@latest

Then, re-run 'kod generate' and re-build your code. If the problem persists,
please file an issue at https://github.com/go-kod/kod/issues.
`)

// kod.InstanceOf checks.
var _ kod.InstanceOf[test1Controller] = (*test1ControllerImpl)(nil)
var _ kod.InstanceOf[testService] = (*serviceImpl)(nil)
var _ kod.InstanceOf[testRepository] = (*modelImpl)(nil)
var _ kod.InstanceOf[Test1Component] = (*test1Component)(nil)
var _ kod.InstanceOf[Test2Component] = (*test2Component)(nil)
var _ kod.InstanceOf[kod.Main] = (*App)(nil)
var _ kod.InstanceOf[ctxInterface] = (*ctxImpl)(nil)
var _ kod.InstanceOf[test1ComponentDefaultError] = (*test1ComponentDefaultErrorImpl)(nil)
var _ kod.InstanceOf[test1ComponentGlobalDefaultError] = (*test1ComponentGlobalDefaultErrorImpl)(nil)
var _ kod.InstanceOf[testEchoController] = (*testEchoControllerImpl)(nil)
var _ kod.InstanceOf[testGinController] = (*testGinControllerImpl)(nil)
var _ kod.InstanceOf[HTTPController] = (*httpControllerImpl)(nil)
var _ kod.InstanceOf[InterceptorRetry] = (*interceptorRetry)(nil)
var _ kod.InstanceOf[LazyInitImpl] = (*lazyInitImpl)(nil)
var _ kod.InstanceOf[LazyInitComponent] = (*lazyInitComponent)(nil)
var _ kod.InstanceOf[panicCaseInterface] = (*panicCase)(nil)
var _ kod.InstanceOf[panicNoRecvoeryCaseInterface] = (*panicNoRecvoeryCase)(nil)

// Local stub implementations.
// test1Controller_local_stub is a local stub implementation of [test1Controller].
type test1Controller_local_stub struct {
	impl        test1Controller
	interceptor interceptor.Interceptor
}

// Check that [test1Controller_local_stub] implements the [test1Controller] interface.
var _ test1Controller = (*test1Controller_local_stub)(nil)

// testService_local_stub is a local stub implementation of [testService].
type testService_local_stub struct {
	impl        testService
	interceptor interceptor.Interceptor
}

// Check that [testService_local_stub] implements the [testService] interface.
var _ testService = (*testService_local_stub)(nil)

// Foo wraps the method [serviceImpl.Foo].
func (s testService_local_stub) Foo(ctx context.Context) (err error) {

	if s.interceptor == nil {
		err = s.impl.Foo(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		err = s.impl.Foo(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: testService_Foo_FullMethodName,
	}

	err = s.interceptor(ctx, info, []any{}, []any{}, call)
	return
}

// testRepository_local_stub is a local stub implementation of [testRepository].
type testRepository_local_stub struct {
	impl        testRepository
	interceptor interceptor.Interceptor
}

// Check that [testRepository_local_stub] implements the [testRepository] interface.
var _ testRepository = (*testRepository_local_stub)(nil)

// Foo wraps the method [modelImpl.Foo].
func (s testRepository_local_stub) Foo(ctx context.Context) (err error) {

	if s.interceptor == nil {
		err = s.impl.Foo(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		err = s.impl.Foo(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: testRepository_Foo_FullMethodName,
	}

	err = s.interceptor(ctx, info, []any{}, []any{}, call)
	return
}

// test1Component_local_stub is a local stub implementation of [Test1Component].
type test1Component_local_stub struct {
	impl        Test1Component
	interceptor interceptor.Interceptor
}

// Check that [test1Component_local_stub] implements the [Test1Component] interface.
var _ Test1Component = (*test1Component_local_stub)(nil)

// Foo wraps the method [test1Component.Foo].
func (s test1Component_local_stub) Foo(ctx context.Context, a1 *FooReq) (r0 *FooRes, err error) {

	if s.interceptor == nil {
		r0, err = s.impl.Foo(ctx, a1)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		r0, err = s.impl.Foo(ctx, a1)
		res[0] = r0
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: Test1Component_Foo_FullMethodName,
	}

	err = s.interceptor(ctx, info, []any{a1}, []any{r0}, call)
	return
}

// test2Component_local_stub is a local stub implementation of [Test2Component].
type test2Component_local_stub struct {
	impl        Test2Component
	interceptor interceptor.Interceptor
}

// Check that [test2Component_local_stub] implements the [Test2Component] interface.
var _ Test2Component = (*test2Component_local_stub)(nil)

// GetClient wraps the method [test2Component.GetClient].
func (s test2Component_local_stub) GetClient() (r0 *http.Client) {
	// Because the first argument is not context.Context, so interceptors are not supported.
	r0 = s.impl.GetClient()
	return
}

// ctxInterface_local_stub is a local stub implementation of [ctxInterface].
type ctxInterface_local_stub struct {
	impl        ctxInterface
	interceptor interceptor.Interceptor
}

// Check that [ctxInterface_local_stub] implements the [ctxInterface] interface.
var _ ctxInterface = (*ctxInterface_local_stub)(nil)

// Foo wraps the method [ctxImpl.Foo].
func (s ctxInterface_local_stub) Foo(ctx context.Context) {

	if s.interceptor == nil {
		s.impl.Foo(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		s.impl.Foo(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: ctxInterface_Foo_FullMethodName,
	}

	_ = s.interceptor(ctx, info, []any{}, []any{}, call)
}

// test1ComponentDefaultError_local_stub is a local stub implementation of [test1ComponentDefaultError].
type test1ComponentDefaultError_local_stub struct {
	impl        test1ComponentDefaultError
	interceptor interceptor.Interceptor
}

// Check that [test1ComponentDefaultError_local_stub] implements the [test1ComponentDefaultError] interface.
var _ test1ComponentDefaultError = (*test1ComponentDefaultError_local_stub)(nil)

// test1ComponentGlobalDefaultError_local_stub is a local stub implementation of [test1ComponentGlobalDefaultError].
type test1ComponentGlobalDefaultError_local_stub struct {
	impl        test1ComponentGlobalDefaultError
	interceptor interceptor.Interceptor
}

// Check that [test1ComponentGlobalDefaultError_local_stub] implements the [test1ComponentGlobalDefaultError] interface.
var _ test1ComponentGlobalDefaultError = (*test1ComponentGlobalDefaultError_local_stub)(nil)

// testEchoController_local_stub is a local stub implementation of [testEchoController].
type testEchoController_local_stub struct {
	impl        testEchoController
	interceptor interceptor.Interceptor
}

// Check that [testEchoController_local_stub] implements the [testEchoController] interface.
var _ testEchoController = (*testEchoController_local_stub)(nil)

// Error wraps the method [testEchoControllerImpl.Error].
func (s testEchoController_local_stub) Error(a0 echo.Context) (err error) {
	// Because the first argument is not context.Context, so interceptors are not supported.
	err = s.impl.Error(a0)
	return
}

// Hello wraps the method [testEchoControllerImpl.Hello].
func (s testEchoController_local_stub) Hello(a0 echo.Context) (err error) {
	// Because the first argument is not context.Context, so interceptors are not supported.
	err = s.impl.Hello(a0)
	return
}

// testGinController_local_stub is a local stub implementation of [testGinController].
type testGinController_local_stub struct {
	impl        testGinController
	interceptor interceptor.Interceptor
}

// Check that [testGinController_local_stub] implements the [testGinController] interface.
var _ testGinController = (*testGinController_local_stub)(nil)

// Hello wraps the method [testGinControllerImpl.Hello].
func (s testGinController_local_stub) Hello(a0 *gin.Context) {
	// Because the first argument is not context.Context, so interceptors are not supported.
	s.impl.Hello(a0)
	return
}

// hTTPController_local_stub is a local stub implementation of [HTTPController].
type hTTPController_local_stub struct {
	impl        HTTPController
	interceptor interceptor.Interceptor
}

// Check that [hTTPController_local_stub] implements the [HTTPController] interface.
var _ HTTPController = (*hTTPController_local_stub)(nil)

// Foo wraps the method [httpControllerImpl.Foo].
func (s hTTPController_local_stub) Foo(a0 http.ResponseWriter, a1 *http.Request) {
	// Because the first argument is not context.Context, so interceptors are not supported.
	s.impl.Foo(a0, a1)
	return
}

// interceptorRetry_local_stub is a local stub implementation of [InterceptorRetry].
type interceptorRetry_local_stub struct {
	impl        InterceptorRetry
	interceptor interceptor.Interceptor
}

// Check that [interceptorRetry_local_stub] implements the [InterceptorRetry] interface.
var _ InterceptorRetry = (*interceptorRetry_local_stub)(nil)

// TestError wraps the method [interceptorRetry.TestError].
func (s interceptorRetry_local_stub) TestError(ctx context.Context) (err error) {

	if s.interceptor == nil {
		err = s.impl.TestError(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		err = s.impl.TestError(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: InterceptorRetry_TestError_FullMethodName,
	}

	err = s.interceptor(ctx, info, []any{}, []any{}, call)
	return
}

// TestNormal wraps the method [interceptorRetry.TestNormal].
func (s interceptorRetry_local_stub) TestNormal(ctx context.Context) (err error) {

	if s.interceptor == nil {
		err = s.impl.TestNormal(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		err = s.impl.TestNormal(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: InterceptorRetry_TestNormal_FullMethodName,
	}

	err = s.interceptor(ctx, info, []any{}, []any{}, call)
	return
}

// lazyInitImpl_local_stub is a local stub implementation of [LazyInitImpl].
type lazyInitImpl_local_stub struct {
	impl        LazyInitImpl
	interceptor interceptor.Interceptor
}

// Check that [lazyInitImpl_local_stub] implements the [LazyInitImpl] interface.
var _ LazyInitImpl = (*lazyInitImpl_local_stub)(nil)

// Try wraps the method [lazyInitImpl.Try].
func (s lazyInitImpl_local_stub) Try(ctx context.Context) {

	if s.interceptor == nil {
		s.impl.Try(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		s.impl.Try(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: LazyInitImpl_Try_FullMethodName,
	}

	_ = s.interceptor(ctx, info, []any{}, []any{}, call)
}

// lazyInitComponent_local_stub is a local stub implementation of [LazyInitComponent].
type lazyInitComponent_local_stub struct {
	impl        LazyInitComponent
	interceptor interceptor.Interceptor
}

// Check that [lazyInitComponent_local_stub] implements the [LazyInitComponent] interface.
var _ LazyInitComponent = (*lazyInitComponent_local_stub)(nil)

// Try wraps the method [lazyInitComponent.Try].
func (s lazyInitComponent_local_stub) Try(ctx context.Context) (err error) {

	if s.interceptor == nil {
		err = s.impl.Try(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		err = s.impl.Try(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: LazyInitComponent_Try_FullMethodName,
	}

	err = s.interceptor(ctx, info, []any{}, []any{}, call)
	return
}

// panicCaseInterface_local_stub is a local stub implementation of [panicCaseInterface].
type panicCaseInterface_local_stub struct {
	impl        panicCaseInterface
	interceptor interceptor.Interceptor
}

// Check that [panicCaseInterface_local_stub] implements the [panicCaseInterface] interface.
var _ panicCaseInterface = (*panicCaseInterface_local_stub)(nil)

// TestPanic wraps the method [panicCase.TestPanic].
func (s panicCaseInterface_local_stub) TestPanic(ctx context.Context) {

	if s.interceptor == nil {
		s.impl.TestPanic(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		s.impl.TestPanic(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: panicCaseInterface_TestPanic_FullMethodName,
	}

	_ = s.interceptor(ctx, info, []any{}, []any{}, call)
}

// panicNoRecvoeryCaseInterface_local_stub is a local stub implementation of [panicNoRecvoeryCaseInterface].
type panicNoRecvoeryCaseInterface_local_stub struct {
	impl        panicNoRecvoeryCaseInterface
	interceptor interceptor.Interceptor
}

// Check that [panicNoRecvoeryCaseInterface_local_stub] implements the [panicNoRecvoeryCaseInterface] interface.
var _ panicNoRecvoeryCaseInterface = (*panicNoRecvoeryCaseInterface_local_stub)(nil)

// TestPanic wraps the method [panicNoRecvoeryCase.TestPanic].
func (s panicNoRecvoeryCaseInterface_local_stub) TestPanic(ctx context.Context) {

	if s.interceptor == nil {
		s.impl.TestPanic(ctx)
		return
	}

	call := func(ctx context.Context, info interceptor.CallInfo, req, res []any) (err error) {
		s.impl.TestPanic(ctx)
		return
	}

	info := interceptor.CallInfo{
		Impl:       s.impl,
		FullMethod: panicNoRecvoeryCaseInterface_TestPanic_FullMethodName,
	}

	_ = s.interceptor(ctx, info, []any{}, []any{}, call)
}