// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/opentofu/opentofu/internal/tfplugin6 (interfaces: ProviderClient)
//
// Generated by this command:
//
//	mockgen -destination mock.go github.com/opentofu/opentofu/internal/tfplugin6 ProviderClient
//

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

import (
	context "context"
	reflect "reflect"

	tfplugin6 "github.com/opentofu/opentofu/internal/tfplugin6"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
)

// 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 *tfplugin6.ApplyResourceChange_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.CallFunction_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.CloseEphemeralResource_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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...)
}

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

// ConfigureProvider indicates an expected call of ConfigureProvider.
func (mr *MockProviderClientMockRecorder) ConfigureProvider(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, "ConfigureProvider", reflect.TypeOf((*MockProviderClient)(nil).ConfigureProvider), varargs...)
}

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

// ConfigureStateStore indicates an expected call of ConfigureStateStore.
func (mr *MockProviderClientMockRecorder) ConfigureStateStore(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, "ConfigureStateStore", reflect.TypeOf((*MockProviderClient)(nil).ConfigureStateStore), varargs...)
}

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

// DeleteState indicates an expected call of DeleteState.
func (mr *MockProviderClientMockRecorder) DeleteState(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, "DeleteState", reflect.TypeOf((*MockProviderClient)(nil).DeleteState), varargs...)
}

// GenerateResourceConfig mocks base method.
func (m *MockProviderClient) GenerateResourceConfig(ctx context.Context, in *tfplugin6.GenerateResourceConfig_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.GetFunctions_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.GetMetadata_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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...)
}

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

// GetProviderSchema indicates an expected call of GetProviderSchema.
func (mr *MockProviderClientMockRecorder) GetProviderSchema(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, "GetProviderSchema", reflect.TypeOf((*MockProviderClient)(nil).GetProviderSchema), varargs...)
}

// GetResourceIdentitySchemas mocks base method.
func (m *MockProviderClient) GetResourceIdentitySchemas(ctx context.Context, in *tfplugin6.GetResourceIdentitySchemas_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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...)
}

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

// GetStates indicates an expected call of GetStates.
func (mr *MockProviderClientMockRecorder) GetStates(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, "GetStates", reflect.TypeOf((*MockProviderClient)(nil).GetStates), varargs...)
}

// ImportResourceState mocks base method.
func (m *MockProviderClient) ImportResourceState(ctx context.Context, in *tfplugin6.ImportResourceState_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.InvokeAction_Request, opts ...grpc.CallOption) (tfplugin6.Provider_InvokeActionClient, 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].(tfplugin6.Provider_InvokeActionClient)
	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 *tfplugin6.ListResource_Request, opts ...grpc.CallOption) (tfplugin6.Provider_ListResourceClient, 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].(tfplugin6.Provider_ListResourceClient)
	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...)
}

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

// LockState indicates an expected call of LockState.
func (mr *MockProviderClientMockRecorder) LockState(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, "LockState", reflect.TypeOf((*MockProviderClient)(nil).LockState), varargs...)
}

// MoveResourceState mocks base method.
func (m *MockProviderClient) MoveResourceState(ctx context.Context, in *tfplugin6.MoveResourceState_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.OpenEphemeralResource_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.PlanAction_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.PlanResourceChange_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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...)
}

// ReadDataSource mocks base method.
func (m *MockProviderClient) ReadDataSource(ctx context.Context, in *tfplugin6.ReadDataSource_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.ReadResource_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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...)
}

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

// ReadStateBytes indicates an expected call of ReadStateBytes.
func (mr *MockProviderClientMockRecorder) ReadStateBytes(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, "ReadStateBytes", reflect.TypeOf((*MockProviderClient)(nil).ReadStateBytes), varargs...)
}

// RenewEphemeralResource mocks base method.
func (m *MockProviderClient) RenewEphemeralResource(ctx context.Context, in *tfplugin6.RenewEphemeralResource_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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...)
}

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

// StopProvider indicates an expected call of StopProvider.
func (mr *MockProviderClientMockRecorder) StopProvider(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, "StopProvider", reflect.TypeOf((*MockProviderClient)(nil).StopProvider), varargs...)
}

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

// UnlockState indicates an expected call of UnlockState.
func (mr *MockProviderClientMockRecorder) UnlockState(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, "UnlockState", reflect.TypeOf((*MockProviderClient)(nil).UnlockState), varargs...)
}

// UpgradeResourceIdentity mocks base method.
func (m *MockProviderClient) UpgradeResourceIdentity(ctx context.Context, in *tfplugin6.UpgradeResourceIdentity_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.UpgradeResourceState_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.ValidateActionConfig_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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...)
}

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

// ValidateDataResourceConfig indicates an expected call of ValidateDataResourceConfig.
func (mr *MockProviderClientMockRecorder) ValidateDataResourceConfig(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, "ValidateDataResourceConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateDataResourceConfig), varargs...)
}

// ValidateEphemeralResourceConfig mocks base method.
func (m *MockProviderClient) ValidateEphemeralResourceConfig(ctx context.Context, in *tfplugin6.ValidateEphemeralResourceConfig_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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 *tfplugin6.ValidateListResourceConfig_Request, opts ...grpc.CallOption) (*tfplugin6.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].(*tfplugin6.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...)
}

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

// ValidateProviderConfig indicates an expected call of ValidateProviderConfig.
func (mr *MockProviderClientMockRecorder) ValidateProviderConfig(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, "ValidateProviderConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateProviderConfig), varargs...)
}

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

// ValidateResourceConfig indicates an expected call of ValidateResourceConfig.
func (mr *MockProviderClientMockRecorder) ValidateResourceConfig(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, "ValidateResourceConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateResourceConfig), varargs...)
}

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

// ValidateStateStoreConfig indicates an expected call of ValidateStateStoreConfig.
func (mr *MockProviderClientMockRecorder) ValidateStateStoreConfig(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, "ValidateStateStoreConfig", reflect.TypeOf((*MockProviderClient)(nil).ValidateStateStoreConfig), varargs...)
}

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

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