// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/hashicorp/terraform/internal/tfplugin5 (interfaces: ProviderClient,ProvisionerClient,Provisioner_ProvisionResourceClient,Provisioner_ProvisionResourceServer,Provider_InvokeActionClient)
//
// Generated by this command:
//
//	mockgen -destination mock.go github.com/hashicorp/terraform/internal/tfplugin5 ProviderClient,ProvisionerClient,Provisioner_ProvisionResourceClient,Provisioner_ProvisionResourceServer,Provider_InvokeActionClient
//

// Package mock_tfplugin5 is a generated GoMock package.
package mock_tfplugin5

import (
	context "context"
	reflect "reflect"

	tfplugin5 "github.com/hashicorp/terraform/internal/tfplugin5"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)

// MockProviderClient is a mock of ProviderClient interface.
type MockProviderClient struct {
	ctrl     *gomock.Controller
	recorder *MockProviderClientMockRecorder
	isgomock struct{}
}

// MockProviderClientMockRecorder is the mock recorder for MockProviderClient.
type MockProviderClientMockRecorder struct {
	mock *MockProviderClient
}

// NewMockProviderClient creates a new mock instance.
func NewMockProviderClient(ctrl *gomock.Controller) *MockProviderClient {
	mock := &MockProviderClient{ctrl: ctrl}
	mock.recorder = &MockProviderClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProviderClient) EXPECT() *MockProviderClientMockRecorder {
	return m.recorder
}

// ApplyResourceChange mocks base method.
func (m *MockProviderClient) ApplyResourceChange(ctx context.Context, in *tfplugin5.ApplyResourceChange_Request, opts ...grpc.CallOption) (*tfplugin5.ApplyResourceChange_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ApplyResourceChange", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ApplyResourceChange_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyResourceChange indicates an expected call of ApplyResourceChange.
func (mr *MockProviderClientMockRecorder) ApplyResourceChange(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyResourceChange", reflect.TypeOf((*MockProviderClient)(nil).ApplyResourceChange), varargs...)
}

// CallFunction mocks base method.
func (m *MockProviderClient) CallFunction(ctx context.Context, in *tfplugin5.CallFunction_Request, opts ...grpc.CallOption) (*tfplugin5.CallFunction_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CallFunction", varargs...)
	ret0, _ := ret[0].(*tfplugin5.CallFunction_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CallFunction indicates an expected call of CallFunction.
func (mr *MockProviderClientMockRecorder) CallFunction(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallFunction", reflect.TypeOf((*MockProviderClient)(nil).CallFunction), varargs...)
}

// CloseEphemeralResource mocks base method.
func (m *MockProviderClient) CloseEphemeralResource(ctx context.Context, in *tfplugin5.CloseEphemeralResource_Request, opts ...grpc.CallOption) (*tfplugin5.CloseEphemeralResource_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CloseEphemeralResource", varargs...)
	ret0, _ := ret[0].(*tfplugin5.CloseEphemeralResource_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CloseEphemeralResource indicates an expected call of CloseEphemeralResource.
func (mr *MockProviderClientMockRecorder) CloseEphemeralResource(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseEphemeralResource", reflect.TypeOf((*MockProviderClient)(nil).CloseEphemeralResource), varargs...)
}

// Configure mocks base method.
func (m *MockProviderClient) Configure(ctx context.Context, in *tfplugin5.Configure_Request, opts ...grpc.CallOption) (*tfplugin5.Configure_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Configure", varargs...)
	ret0, _ := ret[0].(*tfplugin5.Configure_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Configure indicates an expected call of Configure.
func (mr *MockProviderClientMockRecorder) Configure(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Configure", reflect.TypeOf((*MockProviderClient)(nil).Configure), varargs...)
}

// GenerateResourceConfig mocks base method.
func (m *MockProviderClient) GenerateResourceConfig(ctx context.Context, in *tfplugin5.GenerateResourceConfig_Request, opts ...grpc.CallOption) (*tfplugin5.GenerateResourceConfig_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateResourceConfig", varargs...)
	ret0, _ := ret[0].(*tfplugin5.GenerateResourceConfig_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateResourceConfig indicates an expected call of GenerateResourceConfig.
func (mr *MockProviderClientMockRecorder) GenerateResourceConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateResourceConfig", reflect.TypeOf((*MockProviderClient)(nil).GenerateResourceConfig), varargs...)
}

// GetFunctions mocks base method.
func (m *MockProviderClient) GetFunctions(ctx context.Context, in *tfplugin5.GetFunctions_Request, opts ...grpc.CallOption) (*tfplugin5.GetFunctions_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFunctions", varargs...)
	ret0, _ := ret[0].(*tfplugin5.GetFunctions_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFunctions indicates an expected call of GetFunctions.
func (mr *MockProviderClientMockRecorder) GetFunctions(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFunctions", reflect.TypeOf((*MockProviderClient)(nil).GetFunctions), varargs...)
}

// GetMetadata mocks base method.
func (m *MockProviderClient) GetMetadata(ctx context.Context, in *tfplugin5.GetMetadata_Request, opts ...grpc.CallOption) (*tfplugin5.GetMetadata_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMetadata", varargs...)
	ret0, _ := ret[0].(*tfplugin5.GetMetadata_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetadata indicates an expected call of GetMetadata.
func (mr *MockProviderClientMockRecorder) GetMetadata(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockProviderClient)(nil).GetMetadata), varargs...)
}

// GetResourceIdentitySchemas mocks base method.
func (m *MockProviderClient) GetResourceIdentitySchemas(ctx context.Context, in *tfplugin5.GetResourceIdentitySchemas_Request, opts ...grpc.CallOption) (*tfplugin5.GetResourceIdentitySchemas_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetResourceIdentitySchemas", varargs...)
	ret0, _ := ret[0].(*tfplugin5.GetResourceIdentitySchemas_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourceIdentitySchemas indicates an expected call of GetResourceIdentitySchemas.
func (mr *MockProviderClientMockRecorder) GetResourceIdentitySchemas(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceIdentitySchemas", reflect.TypeOf((*MockProviderClient)(nil).GetResourceIdentitySchemas), varargs...)
}

// GetSchema mocks base method.
func (m *MockProviderClient) GetSchema(ctx context.Context, in *tfplugin5.GetProviderSchema_Request, opts ...grpc.CallOption) (*tfplugin5.GetProviderSchema_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSchema", varargs...)
	ret0, _ := ret[0].(*tfplugin5.GetProviderSchema_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSchema indicates an expected call of GetSchema.
func (mr *MockProviderClientMockRecorder) GetSchema(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSchema", reflect.TypeOf((*MockProviderClient)(nil).GetSchema), varargs...)
}

// ImportResourceState mocks base method.
func (m *MockProviderClient) ImportResourceState(ctx context.Context, in *tfplugin5.ImportResourceState_Request, opts ...grpc.CallOption) (*tfplugin5.ImportResourceState_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportResourceState", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ImportResourceState_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportResourceState indicates an expected call of ImportResourceState.
func (mr *MockProviderClientMockRecorder) ImportResourceState(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportResourceState", reflect.TypeOf((*MockProviderClient)(nil).ImportResourceState), varargs...)
}

// InvokeAction mocks base method.
func (m *MockProviderClient) InvokeAction(ctx context.Context, in *tfplugin5.InvokeAction_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin5.InvokeAction_Event], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "InvokeAction", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin5.InvokeAction_Event])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InvokeAction indicates an expected call of InvokeAction.
func (mr *MockProviderClientMockRecorder) InvokeAction(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeAction", reflect.TypeOf((*MockProviderClient)(nil).InvokeAction), varargs...)
}

// ListResource mocks base method.
func (m *MockProviderClient) ListResource(ctx context.Context, in *tfplugin5.ListResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin5.ListResource_Event], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListResource", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin5.ListResource_Event])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListResource indicates an expected call of ListResource.
func (mr *MockProviderClientMockRecorder) ListResource(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResource", reflect.TypeOf((*MockProviderClient)(nil).ListResource), varargs...)
}

// MoveResourceState mocks base method.
func (m *MockProviderClient) MoveResourceState(ctx context.Context, in *tfplugin5.MoveResourceState_Request, opts ...grpc.CallOption) (*tfplugin5.MoveResourceState_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MoveResourceState", varargs...)
	ret0, _ := ret[0].(*tfplugin5.MoveResourceState_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MoveResourceState indicates an expected call of MoveResourceState.
func (mr *MockProviderClientMockRecorder) MoveResourceState(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveResourceState", reflect.TypeOf((*MockProviderClient)(nil).MoveResourceState), varargs...)
}

// OpenEphemeralResource mocks base method.
func (m *MockProviderClient) OpenEphemeralResource(ctx context.Context, in *tfplugin5.OpenEphemeralResource_Request, opts ...grpc.CallOption) (*tfplugin5.OpenEphemeralResource_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OpenEphemeralResource", varargs...)
	ret0, _ := ret[0].(*tfplugin5.OpenEphemeralResource_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenEphemeralResource indicates an expected call of OpenEphemeralResource.
func (mr *MockProviderClientMockRecorder) OpenEphemeralResource(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenEphemeralResource", reflect.TypeOf((*MockProviderClient)(nil).OpenEphemeralResource), varargs...)
}

// PlanAction mocks base method.
func (m *MockProviderClient) PlanAction(ctx context.Context, in *tfplugin5.PlanAction_Request, opts ...grpc.CallOption) (*tfplugin5.PlanAction_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PlanAction", varargs...)
	ret0, _ := ret[0].(*tfplugin5.PlanAction_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PlanAction indicates an expected call of PlanAction.
func (mr *MockProviderClientMockRecorder) PlanAction(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PlanAction", reflect.TypeOf((*MockProviderClient)(nil).PlanAction), varargs...)
}

// PlanResourceChange mocks base method.
func (m *MockProviderClient) PlanResourceChange(ctx context.Context, in *tfplugin5.PlanResourceChange_Request, opts ...grpc.CallOption) (*tfplugin5.PlanResourceChange_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PlanResourceChange", varargs...)
	ret0, _ := ret[0].(*tfplugin5.PlanResourceChange_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PlanResourceChange indicates an expected call of PlanResourceChange.
func (mr *MockProviderClientMockRecorder) PlanResourceChange(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PlanResourceChange", reflect.TypeOf((*MockProviderClient)(nil).PlanResourceChange), varargs...)
}

// PrepareProviderConfig mocks base method.
func (m *MockProviderClient) PrepareProviderConfig(ctx context.Context, in *tfplugin5.PrepareProviderConfig_Request, opts ...grpc.CallOption) (*tfplugin5.PrepareProviderConfig_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PrepareProviderConfig", varargs...)
	ret0, _ := ret[0].(*tfplugin5.PrepareProviderConfig_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PrepareProviderConfig indicates an expected call of PrepareProviderConfig.
func (mr *MockProviderClientMockRecorder) PrepareProviderConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareProviderConfig", reflect.TypeOf((*MockProviderClient)(nil).PrepareProviderConfig), varargs...)
}

// ReadDataSource mocks base method.
func (m *MockProviderClient) ReadDataSource(ctx context.Context, in *tfplugin5.ReadDataSource_Request, opts ...grpc.CallOption) (*tfplugin5.ReadDataSource_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReadDataSource", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ReadDataSource_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadDataSource indicates an expected call of ReadDataSource.
func (mr *MockProviderClientMockRecorder) ReadDataSource(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadDataSource", reflect.TypeOf((*MockProviderClient)(nil).ReadDataSource), varargs...)
}

// ReadResource mocks base method.
func (m *MockProviderClient) ReadResource(ctx context.Context, in *tfplugin5.ReadResource_Request, opts ...grpc.CallOption) (*tfplugin5.ReadResource_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReadResource", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ReadResource_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadResource indicates an expected call of ReadResource.
func (mr *MockProviderClientMockRecorder) ReadResource(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadResource", reflect.TypeOf((*MockProviderClient)(nil).ReadResource), varargs...)
}

// RenewEphemeralResource mocks base method.
func (m *MockProviderClient) RenewEphemeralResource(ctx context.Context, in *tfplugin5.RenewEphemeralResource_Request, opts ...grpc.CallOption) (*tfplugin5.RenewEphemeralResource_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RenewEphemeralResource", varargs...)
	ret0, _ := ret[0].(*tfplugin5.RenewEphemeralResource_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RenewEphemeralResource indicates an expected call of RenewEphemeralResource.
func (mr *MockProviderClientMockRecorder) RenewEphemeralResource(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenewEphemeralResource", reflect.TypeOf((*MockProviderClient)(nil).RenewEphemeralResource), varargs...)
}

// Stop mocks base method.
func (m *MockProviderClient) Stop(ctx context.Context, in *tfplugin5.Stop_Request, opts ...grpc.CallOption) (*tfplugin5.Stop_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Stop", varargs...)
	ret0, _ := ret[0].(*tfplugin5.Stop_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stop indicates an expected call of Stop.
func (mr *MockProviderClientMockRecorder) Stop(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockProviderClient)(nil).Stop), varargs...)
}

// UpgradeResourceIdentity mocks base method.
func (m *MockProviderClient) UpgradeResourceIdentity(ctx context.Context, in *tfplugin5.UpgradeResourceIdentity_Request, opts ...grpc.CallOption) (*tfplugin5.UpgradeResourceIdentity_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpgradeResourceIdentity", varargs...)
	ret0, _ := ret[0].(*tfplugin5.UpgradeResourceIdentity_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpgradeResourceIdentity indicates an expected call of UpgradeResourceIdentity.
func (mr *MockProviderClientMockRecorder) UpgradeResourceIdentity(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeResourceIdentity", reflect.TypeOf((*MockProviderClient)(nil).UpgradeResourceIdentity), varargs...)
}

// UpgradeResourceState mocks base method.
func (m *MockProviderClient) UpgradeResourceState(ctx context.Context, in *tfplugin5.UpgradeResourceState_Request, opts ...grpc.CallOption) (*tfplugin5.UpgradeResourceState_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpgradeResourceState", varargs...)
	ret0, _ := ret[0].(*tfplugin5.UpgradeResourceState_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpgradeResourceState indicates an expected call of UpgradeResourceState.
func (mr *MockProviderClientMockRecorder) UpgradeResourceState(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeResourceState", reflect.TypeOf((*MockProviderClient)(nil).UpgradeResourceState), varargs...)
}

// ValidateActionConfig mocks base method.
func (m *MockProviderClient) ValidateActionConfig(ctx context.Context, in *tfplugin5.ValidateActionConfig_Request, opts ...grpc.CallOption) (*tfplugin5.ValidateActionConfig_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateActionConfig", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ValidateActionConfig_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateActionConfig indicates an expected call of ValidateActionConfig.
func (mr *MockProviderClientMockRecorder) ValidateActionConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateActionConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateActionConfig), varargs...)
}

// ValidateDataSourceConfig mocks base method.
func (m *MockProviderClient) ValidateDataSourceConfig(ctx context.Context, in *tfplugin5.ValidateDataSourceConfig_Request, opts ...grpc.CallOption) (*tfplugin5.ValidateDataSourceConfig_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateDataSourceConfig", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ValidateDataSourceConfig_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateDataSourceConfig indicates an expected call of ValidateDataSourceConfig.
func (mr *MockProviderClientMockRecorder) ValidateDataSourceConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateDataSourceConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateDataSourceConfig), varargs...)
}

// ValidateEphemeralResourceConfig mocks base method.
func (m *MockProviderClient) ValidateEphemeralResourceConfig(ctx context.Context, in *tfplugin5.ValidateEphemeralResourceConfig_Request, opts ...grpc.CallOption) (*tfplugin5.ValidateEphemeralResourceConfig_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateEphemeralResourceConfig", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ValidateEphemeralResourceConfig_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateEphemeralResourceConfig indicates an expected call of ValidateEphemeralResourceConfig.
func (mr *MockProviderClientMockRecorder) ValidateEphemeralResourceConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateEphemeralResourceConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateEphemeralResourceConfig), varargs...)
}

// ValidateListResourceConfig mocks base method.
func (m *MockProviderClient) ValidateListResourceConfig(ctx context.Context, in *tfplugin5.ValidateListResourceConfig_Request, opts ...grpc.CallOption) (*tfplugin5.ValidateListResourceConfig_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateListResourceConfig", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ValidateListResourceConfig_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateListResourceConfig indicates an expected call of ValidateListResourceConfig.
func (mr *MockProviderClientMockRecorder) ValidateListResourceConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateListResourceConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateListResourceConfig), varargs...)
}

// ValidateResourceTypeConfig mocks base method.
func (m *MockProviderClient) ValidateResourceTypeConfig(ctx context.Context, in *tfplugin5.ValidateResourceTypeConfig_Request, opts ...grpc.CallOption) (*tfplugin5.ValidateResourceTypeConfig_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateResourceTypeConfig", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ValidateResourceTypeConfig_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateResourceTypeConfig indicates an expected call of ValidateResourceTypeConfig.
func (mr *MockProviderClientMockRecorder) ValidateResourceTypeConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateResourceTypeConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateResourceTypeConfig), varargs...)
}

// MockProvisionerClient is a mock of ProvisionerClient interface.
type MockProvisionerClient struct {
	ctrl     *gomock.Controller
	recorder *MockProvisionerClientMockRecorder
	isgomock struct{}
}

// MockProvisionerClientMockRecorder is the mock recorder for MockProvisionerClient.
type MockProvisionerClientMockRecorder struct {
	mock *MockProvisionerClient
}

// NewMockProvisionerClient creates a new mock instance.
func NewMockProvisionerClient(ctrl *gomock.Controller) *MockProvisionerClient {
	mock := &MockProvisionerClient{ctrl: ctrl}
	mock.recorder = &MockProvisionerClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProvisionerClient) EXPECT() *MockProvisionerClientMockRecorder {
	return m.recorder
}

// GetSchema mocks base method.
func (m *MockProvisionerClient) GetSchema(ctx context.Context, in *tfplugin5.GetProvisionerSchema_Request, opts ...grpc.CallOption) (*tfplugin5.GetProvisionerSchema_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSchema", varargs...)
	ret0, _ := ret[0].(*tfplugin5.GetProvisionerSchema_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSchema indicates an expected call of GetSchema.
func (mr *MockProvisionerClientMockRecorder) GetSchema(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSchema", reflect.TypeOf((*MockProvisionerClient)(nil).GetSchema), varargs...)
}

// ProvisionResource mocks base method.
func (m *MockProvisionerClient) ProvisionResource(ctx context.Context, in *tfplugin5.ProvisionResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin5.ProvisionResource_Response], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProvisionResource", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin5.ProvisionResource_Response])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ProvisionResource indicates an expected call of ProvisionResource.
func (mr *MockProvisionerClientMockRecorder) ProvisionResource(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionResource", reflect.TypeOf((*MockProvisionerClient)(nil).ProvisionResource), varargs...)
}

// Stop mocks base method.
func (m *MockProvisionerClient) Stop(ctx context.Context, in *tfplugin5.Stop_Request, opts ...grpc.CallOption) (*tfplugin5.Stop_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Stop", varargs...)
	ret0, _ := ret[0].(*tfplugin5.Stop_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stop indicates an expected call of Stop.
func (mr *MockProvisionerClientMockRecorder) Stop(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockProvisionerClient)(nil).Stop), varargs...)
}

// ValidateProvisionerConfig mocks base method.
func (m *MockProvisionerClient) ValidateProvisionerConfig(ctx context.Context, in *tfplugin5.ValidateProvisionerConfig_Request, opts ...grpc.CallOption) (*tfplugin5.ValidateProvisionerConfig_Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateProvisionerConfig", varargs...)
	ret0, _ := ret[0].(*tfplugin5.ValidateProvisionerConfig_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateProvisionerConfig indicates an expected call of ValidateProvisionerConfig.
func (mr *MockProvisionerClientMockRecorder) ValidateProvisionerConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateProvisionerConfig", reflect.TypeOf((*MockProvisionerClient)(nil).ValidateProvisionerConfig), varargs...)
}

// MockProvisioner_ProvisionResourceClient is a mock of Provisioner_ProvisionResourceClient interface.
type MockProvisioner_ProvisionResourceClient[Res any] struct {
	ctrl     *gomock.Controller
	recorder *MockProvisioner_ProvisionResourceClientMockRecorder[Res]
	isgomock struct{}
}

// MockProvisioner_ProvisionResourceClientMockRecorder is the mock recorder for MockProvisioner_ProvisionResourceClient.
type MockProvisioner_ProvisionResourceClientMockRecorder[Res any] struct {
	mock *MockProvisioner_ProvisionResourceClient[Res]
}

// NewMockProvisioner_ProvisionResourceClient creates a new mock instance.
func NewMockProvisioner_ProvisionResourceClient[Res any](ctrl *gomock.Controller) *MockProvisioner_ProvisionResourceClient[Res] {
	mock := &MockProvisioner_ProvisionResourceClient[Res]{ctrl: ctrl}
	mock.recorder = &MockProvisioner_ProvisionResourceClientMockRecorder[Res]{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProvisioner_ProvisionResourceClient[Res]) EXPECT() *MockProvisioner_ProvisionResourceClientMockRecorder[Res] {
	return m.recorder
}

// CloseSend mocks base method.
func (m *MockProvisioner_ProvisionResourceClient[Res]) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).CloseSend))
}

// Context mocks base method.
func (m *MockProvisioner_ProvisionResourceClient[Res]) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).Context))
}

// Header mocks base method.
func (m *MockProvisioner_ProvisionResourceClient[Res]) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).Header))
}

// Recv mocks base method.
func (m *MockProvisioner_ProvisionResourceClient[Res]) Recv() (*tfplugin5.ProvisionResource_Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*tfplugin5.ProvisionResource_Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockProvisioner_ProvisionResourceClient[Res]) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockProvisioner_ProvisionResourceClient[Res]) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockProvisioner_ProvisionResourceClient[Res]) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).Trailer))
}

// MockProvisioner_ProvisionResourceServer is a mock of Provisioner_ProvisionResourceServer interface.
type MockProvisioner_ProvisionResourceServer[Res any] struct {
	ctrl     *gomock.Controller
	recorder *MockProvisioner_ProvisionResourceServerMockRecorder[Res]
	isgomock struct{}
}

// MockProvisioner_ProvisionResourceServerMockRecorder is the mock recorder for MockProvisioner_ProvisionResourceServer.
type MockProvisioner_ProvisionResourceServerMockRecorder[Res any] struct {
	mock *MockProvisioner_ProvisionResourceServer[Res]
}

// NewMockProvisioner_ProvisionResourceServer creates a new mock instance.
func NewMockProvisioner_ProvisionResourceServer[Res any](ctrl *gomock.Controller) *MockProvisioner_ProvisionResourceServer[Res] {
	mock := &MockProvisioner_ProvisionResourceServer[Res]{ctrl: ctrl}
	mock.recorder = &MockProvisioner_ProvisionResourceServerMockRecorder[Res]{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProvisioner_ProvisionResourceServer[Res]) EXPECT() *MockProvisioner_ProvisionResourceServerMockRecorder[Res] {
	return m.recorder
}

// Context mocks base method.
func (m *MockProvisioner_ProvisionResourceServer[Res]) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockProvisioner_ProvisionResourceServer[Res]) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockProvisioner_ProvisionResourceServer[Res]) Send(arg0 *tfplugin5.ProvisionResource_Response) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockProvisioner_ProvisionResourceServer[Res]) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockProvisioner_ProvisionResourceServer[Res]) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockProvisioner_ProvisionResourceServer[Res]) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockProvisioner_ProvisionResourceServer[Res]) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).SetTrailer), arg0)
}

// MockProvider_InvokeActionClient is a mock of Provider_InvokeActionClient interface.
type MockProvider_InvokeActionClient[Res any] struct {
	ctrl     *gomock.Controller
	recorder *MockProvider_InvokeActionClientMockRecorder[Res]
	isgomock struct{}
}

// MockProvider_InvokeActionClientMockRecorder is the mock recorder for MockProvider_InvokeActionClient.
type MockProvider_InvokeActionClientMockRecorder[Res any] struct {
	mock *MockProvider_InvokeActionClient[Res]
}

// NewMockProvider_InvokeActionClient creates a new mock instance.
func NewMockProvider_InvokeActionClient[Res any](ctrl *gomock.Controller) *MockProvider_InvokeActionClient[Res] {
	mock := &MockProvider_InvokeActionClient[Res]{ctrl: ctrl}
	mock.recorder = &MockProvider_InvokeActionClientMockRecorder[Res]{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProvider_InvokeActionClient[Res]) EXPECT() *MockProvider_InvokeActionClientMockRecorder[Res] {
	return m.recorder
}

// CloseSend mocks base method.
func (m *MockProvider_InvokeActionClient[Res]) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).CloseSend))
}

// Context mocks base method.
func (m *MockProvider_InvokeActionClient[Res]) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Context))
}

// Header mocks base method.
func (m *MockProvider_InvokeActionClient[Res]) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Header))
}

// Recv mocks base method.
func (m *MockProvider_InvokeActionClient[Res]) Recv() (*tfplugin5.InvokeAction_Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*tfplugin5.InvokeAction_Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockProvider_InvokeActionClient[Res]) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockProvider_InvokeActionClient[Res]) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockProvider_InvokeActionClient[Res]) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Trailer))
}
