// Package dialecttest provides route-construction dependencies for dialect
// tests. The stubs are deliberately behaviorless: route registration should
// prove that every handler can be assembled from the neutral contract surface
// without exercising the handlers themselves.
package dialecttest

import (
	"context"
	"io"
	"strings"

	"github.com/nexuscrm/shared/pkg/contract"
	"github.com/nexuscrm/shared/pkg/models"
	"github.com/nexuscrm/shared/pkg/queryspec"
)

func ContractDeps() contract.Deps {
	return contract.Deps{
		Records:                   &Records{},
		RecordMutationCoordinator: &RecordMutationCoordinator{},
		RecycleBin:                &RecycleBin{},
		Query:                     &Query{},
		BulkJobs:                  &BulkJobs{},
		BulkIngest:                &BulkIngest{},
		Metadata:                  &Metadata{},
		MetadataAuthoring:         &MetadataAuthoring{},
		MetadataDeploy:            &MetadataDeploy{},
		ApplicationNavigation:     &ApplicationNavigation{},
		MetadataMaintenance:       &MetadataMaintenance{},
		RollupMaintenance:         &RollupMaintenance{},
		Policy:                    &Policy{},
		Notifications:             &Notifications{},
		PermissionAdmin:           &PermissionAdmin{},
		ConnectorSyncStatus:       &ConnectorSyncStatus{},
		ConnectorWebhookSecrets:   &ConnectorWebhookSecrets{},
		Activity:                  &Activity{},
		Files:                     &Files{},
		FlowExecutor:              &FlowExecutor{},
		FlowCatalog:               &FlowCatalog{},
		FlowInterviews:            &FlowInterviews{},
		FlowAuthoring:             &FlowAuthoring{},
		Approvals:                 &Approvals{},
		StandardActions:           &StandardActions{},
	}
}

type Records struct{}

func (*Records) Insert(context.Context, string, contract.Record, *models.UserSession) (contract.Record, error) {
	return nil, nil
}

func (*Records) Retrieve(context.Context, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}

func (*Records) RetrieveMany(context.Context, string, []string, *models.UserSession) (map[string]contract.Record, error) {
	return nil, nil
}

func (*Records) Update(context.Context, string, string, contract.Record, *models.UserSession) error {
	return nil
}

func (*Records) Delete(context.Context, string, string, *models.UserSession) error {
	return nil
}

func (*Records) UpsertByExternalID(context.Context, string, string, string, contract.Record, *models.UserSession) (contract.Record, bool, error) {
	return nil, false, nil
}

func (*Records) RetrieveByField(context.Context, string, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}

func (*Records) CreateRecords(context.Context, []contract.Record, bool, *models.UserSession) ([]contract.RecordMutationResult, error) {
	return nil, nil
}

func (*Records) UpdateRecords(context.Context, []contract.Record, bool, *models.UserSession) ([]contract.RecordMutationResult, error) {
	return nil, nil
}

func (*Records) DeleteRecords(context.Context, []string, bool, *models.UserSession) ([]contract.RecordMutationResult, error) {
	return nil, nil
}

func (*Records) UpsertRecords(context.Context, string, string, []contract.Record, bool, *models.UserSession) ([]contract.RecordMutationResult, error) {
	return nil, nil
}

func (*Records) RetrieveRecords(context.Context, string, []string, []string, *models.UserSession) ([]contract.Record, error) {
	return nil, nil
}

func (*Records) CreateTree(context.Context, string, []contract.Record, *models.UserSession) ([]contract.Record, error) {
	return nil, nil
}

func (*Records) ObjectTypeForID(context.Context, string) (string, error) {
	return "", nil
}

func (*Records) ObjectTypesForIDs(context.Context, []string) (map[string]string, error) {
	return nil, nil
}

func (*Records) RetrieveWithAccess(context.Context, string, string, *models.UserSession) (contract.Record, *contract.RecordAccess, error) {
	return nil, nil, nil
}

func (*Records) BatchRecordAccess(context.Context, string, []string, *models.UserSession) (map[string]contract.RecordAccess, error) {
	return nil, nil
}

func (*Records) ValidateSiblingMaxDefaultConfig(context.Context, string, string) error {
	return nil
}

func (*Records) ValidateSiblingMaxDefaultParentForCreate(context.Context, string, string, any, *models.UserSession) error {
	return nil
}

func (*Records) PreviewSiblingMaxDefault(context.Context, string, string, string, any) (int64, error) {
	return 0, nil
}

type RecordMutationCoordinator struct{}

func (*RecordMutationCoordinator) RunInPessimisticTransaction(ctx context.Context, fn func(context.Context) error) error {
	return fn(ctx)
}

func (*RecordMutationCoordinator) RequiresSourceAwareTransaction(string) bool {
	return false
}

type BulkJobs struct{}

func (*BulkJobs) CreateJob(context.Context, *models.BulkJob) error {
	return nil
}

func (*BulkJobs) GetJob(context.Context, string) (*models.BulkJob, error) {
	return nil, nil
}

func (*BulkJobs) UpdateJob(context.Context, *models.BulkJob) error {
	return nil
}

type BulkIngest struct{}

func (*BulkIngest) CreateIngestJob(context.Context, contract.BulkIngestCreateRequest, *models.UserSession) (*models.BulkJob, error) {
	return nil, nil
}

func (*BulkIngest) GetIngestJob(context.Context, string, *models.UserSession) (*models.BulkJob, error) {
	return nil, nil
}

func (*BulkIngest) CloseIngestJob(context.Context, string, models.BulkJobState, *models.UserSession) (*models.BulkJob, error) {
	return nil, nil
}

func (*BulkIngest) UploadIngestData(context.Context, contract.BulkIngestUploadRequest, *models.UserSession) error {
	return nil
}

type MetadataDeploy struct{}

func (*MetadataDeploy) StartMetadataDeploy(context.Context) (string, error) {
	return "deploy-1", nil
}

func (*MetadataDeploy) CompleteMetadataDeploy(context.Context, string, contract.MetadataDeployResult) error {
	return nil
}

func (*MetadataDeploy) GetMetadataDeployResult(context.Context, string) (*contract.MetadataDeployResult, bool, error) {
	return nil, false, nil
}

func (*MetadataDeploy) ApplyMetadataDeployRecord(context.Context, contract.MetadataDeployRecordRequest, *models.UserSession) (*contract.MetadataDeployRecordResult, error) {
	return nil, nil
}

type Files struct{}

func (*Files) StoreDetachedFile(context.Context, contract.FileUploadRequest) (*contract.FileUploadResult, error) {
	return nil, nil
}

func (*Files) StoreRecordAttachment(context.Context, contract.FileUploadRequest) (*contract.FileUploadResult, error) {
	return nil, nil
}

func (*Files) OpenDetachedFile(context.Context, contract.FileBlobReference, *models.UserSession) (*contract.FileDownload, error) {
	return &contract.FileDownload{Reader: io.NopCloser(strings.NewReader("")), ContentType: "application/octet-stream"}, nil
}

func (*Files) OpenRecordAttachment(context.Context, string, *models.UserSession) (*contract.FileDownload, bool, error) {
	return &contract.FileDownload{Reader: io.NopCloser(strings.NewReader("")), ContentType: "application/octet-stream"}, true, nil
}

func (*Files) AuthorizeRecordAttachmentMetadata(context.Context, string, *models.UserSession) (*contract.RecordAttachmentMetadata, bool, error) {
	return nil, false, nil
}

func (*Files) ResolveAuthorizedRecordAttachmentSource(context.Context, contract.RecordAttachmentSourceRequest, contract.RecordAttachmentSourceLookup, *models.UserSession) (*contract.RecordAttachmentSourceResult, bool, error) {
	return nil, false, nil
}

func (*Files) DeleteRecordAttachment(context.Context, string, *models.UserSession) error {
	return nil
}

type RecycleBin struct{}

func (*RecycleBin) ListRecycleBin(context.Context, *models.UserSession, contract.RecycleBinScope) (*contract.RecycleBinListResult, error) {
	return nil, nil
}

func (*RecycleBin) RestoreRecycleBinRecord(context.Context, string, *models.UserSession) error {
	return nil
}

func (*RecycleBin) PurgeRecycleBinRecord(context.Context, string, *models.UserSession) error {
	return nil
}

type Activity struct{}

func (*Activity) TrackRecordAccess(context.Context, string, string, string) {}

func (*Activity) RelevantItems(context.Context, string, []string, string) ([]contract.RelevantItem, string, error) {
	return nil, "", nil
}

type Query struct{}

func (*Query) Query(context.Context, queryspec.QuerySpec, *models.UserSession) (*contract.QueryResult, error) {
	return nil, nil
}

func (*Query) SearchWithSpec(context.Context, queryspec.SearchSpec, *models.UserSession) ([]contract.Record, error) {
	return nil, nil
}

func (*Query) GlobalSearchWithSpec(context.Context, queryspec.GlobalSearchSpec, *models.UserSession) ([]contract.SearchResult, error) {
	return nil, nil
}

func (*Query) QueryHistory(context.Context, contract.HistoryQueryRequest, *models.UserSession) (*contract.HistoryQueryResult, error) {
	return nil, nil
}

type Metadata struct{}

func (*Metadata) Describe(context.Context, string) (*models.ObjectMetadata, error) {
	return nil, nil
}

func (*Metadata) ListObjects(context.Context) ([]models.ObjectMetadata, error) {
	return nil, nil
}

func (*Metadata) Relationships(context.Context, string) ([]*models.Relationship, error) {
	return nil, nil
}

func (*Metadata) ChildRelationships(context.Context, string) ([]*models.ObjectMetadata, error) {
	return nil, nil
}

func (*Metadata) KeyPrefix(context.Context, string) (string, bool) {
	return "", false
}

func (*Metadata) ResolveLayout(context.Context, string, *models.UserSession, string) (*models.PageLayout, error) {
	return nil, nil
}

func (*Metadata) ResolvePicklistValuesForRecordType(context.Context, string, string, string) (*models.ScopedPicklistValueSet, error) {
	return nil, nil
}

func (*Metadata) ResolveRelatedListResolution(context.Context, string, string) (*contract.RelatedListResolution, bool) {
	return nil, false
}
func (*Metadata) Actions(context.Context, string) ([]*models.ActionMetadata, error) {
	return nil, nil
}

func (*Metadata) ActionByID(context.Context, string) (*models.ActionMetadata, error) {
	return nil, nil
}

func (*Metadata) ListLayouts(context.Context, string) ([]*models.PageLayout, error) {
	return nil, nil
}

func (*Metadata) GetLayoutByID(context.Context, string) (*models.PageLayout, error) {
	return nil, nil
}

func (*Metadata) GetLayoutForAuthoring(context.Context, string) (*models.PageLayout, error) {
	return nil, nil
}

func (*Metadata) ListLayoutAssignments(context.Context, string) ([]*models.LayoutAssignment, error) {
	return nil, nil
}

func (*Metadata) ListApprovalLayouts(context.Context, string) ([]*models.ApprovalPageLayout, error) {
	return nil, nil
}

func (*Metadata) GetApprovalLayoutByID(context.Context, string) (*models.ApprovalPageLayout, error) {
	return nil, nil
}

func (*Metadata) ListViews(context.Context, string, *models.UserSession) ([]*models.ListView, error) {
	return nil, nil
}

func (*Metadata) RecordTypes(context.Context, string) ([]*models.RecordType, error) {
	return nil, nil
}

type Notifications struct{}

func (*Notifications) SendEmail(context.Context, *contract.OutboundEmailMessage) (*contract.OutboundEmailResult, error) {
	return nil, nil
}

func (*Notifications) FrontendBaseURL(context.Context) string {
	return ""
}

type MetadataAuthoring struct{}

func (*MetadataAuthoring) ListSchemasForAuthoring(context.Context) []*models.ObjectMetadata {
	return nil
}

func (*MetadataAuthoring) GetEffectiveSchemaForAuthoring(context.Context, string, *models.UserSession) *models.ObjectMetadata {
	return nil
}

func (*MetadataAuthoring) SharingParentRelationship(context.Context, string) *models.Relationship {
	return nil
}

func (*MetadataAuthoring) CreateSchema(context.Context, contract.MetadataSchemaCreateRequest) (*models.ObjectMetadata, error) {
	return nil, nil
}

func (*MetadataAuthoring) UpdateSchema(context.Context, string, *models.ObjectMetadata) error {
	return nil
}

func (*MetadataAuthoring) DeleteSchema(context.Context, string) error {
	return nil
}

func (*MetadataAuthoring) RefreshAuthoringMetadataCache(context.Context) error {
	return nil
}

func (*MetadataAuthoring) CreateField(context.Context, string, *models.FieldMetadata) error {
	return nil
}

func (*MetadataAuthoring) BatchCreateFields(context.Context, string, []models.FieldMetadata) ([]*models.FieldMetadata, error) {
	return nil, nil
}

func (*MetadataAuthoring) UpdateField(context.Context, string, string, *models.FieldMetadata, contract.FieldPatchPresence) error {
	return nil
}

func (*MetadataAuthoring) DeleteField(context.Context, string, string) error {
	return nil
}

func (*MetadataAuthoring) ListValidationRules(context.Context, string) []models.ValidationRule {
	return nil
}

func (*MetadataAuthoring) CreateValidationRule(context.Context, *models.ValidationRule) error {
	return nil
}

func (*MetadataAuthoring) UpdateValidationRule(context.Context, string, *models.ValidationRule) error {
	return nil
}

func (*MetadataAuthoring) DeleteValidationRule(context.Context, string) error {
	return nil
}

func (*MetadataAuthoring) CreateAction(context.Context, *models.ActionMetadata) error {
	return nil
}

func (*MetadataAuthoring) CreateLayoutAssignment(context.Context, *models.LayoutAssignment) error {
	return nil
}

func (*MetadataAuthoring) SaveLayout(context.Context, *models.PageLayout) error {
	return nil
}

func (*MetadataAuthoring) WriteLayoutHistory(context.Context, string, string, *string) {}

func (*MetadataAuthoring) SetDefaultLayout(context.Context, string, string, *string) error {
	return nil
}

func (*MetadataAuthoring) DeleteLayout(context.Context, string) error {
	return nil
}

func (*MetadataAuthoring) RestoreLayout(context.Context, string, int) error {
	return nil
}

func (*MetadataAuthoring) DeleteLayoutAssignment(context.Context, string) error {
	return nil
}

func (*MetadataAuthoring) SaveApprovalLayout(context.Context, *models.ApprovalPageLayout) error {
	return nil
}

func (*MetadataAuthoring) SetDefaultApprovalLayout(context.Context, string, string) error {
	return nil
}

func (*MetadataAuthoring) DeleteApprovalLayout(context.Context, string) error {
	return nil
}

type ApplicationNavigation struct{}

func (*ApplicationNavigation) ListApplications(context.Context) ([]*models.AppConfig, error) {
	return nil, nil
}

func (*ApplicationNavigation) ListVisibleApplications(context.Context, *models.UserSession) ([]*models.AppConfig, error) {
	return nil, nil
}

func (*ApplicationNavigation) GetApplication(context.Context, string) (*models.AppConfig, error) {
	return nil, nil
}

func (*ApplicationNavigation) CreateApplication(context.Context, *models.AppConfig) error {
	return nil
}

func (*ApplicationNavigation) UpdateApplication(context.Context, string, *models.AppConfig, contract.ApplicationPatchPresence) error {
	return nil
}

func (*ApplicationNavigation) DeleteApplication(context.Context, string) error {
	return nil
}

type MetadataMaintenance struct{}

func (*MetadataMaintenance) RefreshAutoNumberMetadata(context.Context) (*contract.AutoNumberMetadataRefreshResult, error) {
	return &contract.AutoNumberMetadataRefreshResult{InProcess: true}, nil
}

func (*MetadataMaintenance) FormulaViewStatus(context.Context, string) (*contract.FormulaViewStatusResult, error) {
	return &contract.FormulaViewStatusResult{}, nil
}

func (*MetadataMaintenance) PreviewFormulaViewDDL(context.Context, string) (*contract.FormulaViewDDLResult, error) {
	return &contract.FormulaViewDDLResult{}, nil
}

func (*MetadataMaintenance) RebuildFormulaView(context.Context, string) (*contract.FormulaViewRebuildResult, error) {
	return &contract.FormulaViewRebuildResult{}, nil
}

func (*MetadataMaintenance) RebuildAllFormulaViews(context.Context) (*contract.FormulaViewRebuildAllResult, error) {
	return &contract.FormulaViewRebuildAllResult{}, nil
}

func (*MetadataMaintenance) ValidateFormulaView(context.Context, contract.FormulaViewValidationRequest) (*contract.FormulaViewValidationResult, error) {
	return &contract.FormulaViewValidationResult{}, nil
}

type RollupMaintenance struct{}

func (*RollupMaintenance) RecalculateRollups(context.Context, contract.RollupRecalculateRequest) (*contract.RollupRecalculateResult, error) {
	return &contract.RollupRecalculateResult{}, nil
}

type Policy struct{}

func (*Policy) Access(context.Context, *models.UserSession, string, contract.AccessRequest) (*contract.EffectiveObjectAccess, error) {
	return nil, nil
}

func (*Policy) HasCapability(context.Context, *models.UserSession, contract.Capability) bool {
	return false
}

type PermissionAdmin struct{}

func (*PermissionAdmin) ListObjectPermissions(context.Context, *models.UserSession) ([]contract.ObjectAccessProjection, error) {
	return nil, nil
}

func (*PermissionAdmin) ListSystemPermissionCatalog(context.Context) ([]contract.CapabilityCatalogEntry, error) {
	return nil, nil
}

func (*PermissionAdmin) GetPermissionSetSystemGrants(context.Context, string) (map[string]bool, error) {
	return nil, nil
}

func (*PermissionAdmin) SavePermissionSetSystemGrants(context.Context, string, map[string]bool, *models.UserSession) error {
	return nil
}

func (*PermissionAdmin) EffectivePermissions(context.Context, *models.UserSession, string) (*contract.EffectivePermissionsResult, error) {
	return nil, nil
}

func (*PermissionAdmin) ListRecordTypeCatalog(context.Context) ([]contract.PermissionRecordTypeCatalogEntry, error) {
	return nil, nil
}

func (*PermissionAdmin) GetPermissionSetRecordTypeGrants(context.Context, string) ([]contract.RecordTypeVisibilityGrant, error) {
	return nil, nil
}

func (*PermissionAdmin) SavePermissionSetRecordTypeGrants(context.Context, string, map[string]contract.PermissionRecordTypeGrantChange) error {
	return nil
}

func (*PermissionAdmin) ListCustomPermissionCatalog(context.Context) ([]contract.CustomCapabilityCatalogEntry, error) {
	return nil, nil
}

func (*PermissionAdmin) GetPermissionSetCustomPermissionGrants(context.Context, string) ([]contract.CustomCapabilityGrant, error) {
	return nil, nil
}

func (*PermissionAdmin) SavePermissionSetCustomPermissionGrants(context.Context, string, map[string]bool) error {
	return nil
}

type ConnectorSyncStatus struct{}

func (*ConnectorSyncStatus) GetConnectorSyncStatus(context.Context, *models.UserSession, string, string) (*contract.ConnectorSyncStatusResult, error) {
	return nil, nil
}

type ConnectorWebhookSecrets struct{}

func (*ConnectorWebhookSecrets) ListConnectorWebhookSecrets(context.Context, string) ([]contract.ConnectorWebhookSecret, error) {
	return nil, nil
}

func (*ConnectorWebhookSecrets) RotateConnectorWebhookSecret(context.Context, string, string) (*contract.ConnectorWebhookSecretRotation, error) {
	return nil, nil
}

type FlowExecutor struct{}

func (*FlowExecutor) ExecuteFlow(context.Context, string, map[string]any, *models.UserSession) (*contract.FlowExecutionResult, error) {
	return nil, nil
}

func (*FlowExecutor) ResumeInterview(context.Context, string, *models.UserSession) error {
	return nil
}

type FlowCatalog struct{}

func (*FlowCatalog) ProtectedFlowNames(context.Context) ([]string, error) {
	return nil, nil
}

func (*FlowCatalog) ListFlows(context.Context) ([]contract.FlowDescriptor, error) {
	return nil, nil
}

func (*FlowCatalog) GetFlow(context.Context, string) (*contract.FlowDescriptor, error) {
	return nil, nil
}

func (*FlowCatalog) GetFlowRevision(context.Context, string) (*contract.FlowRevisionDescriptor, error) {
	return nil, nil
}

type FlowInterviews struct{}

func (*FlowInterviews) ListFlowInterviews(context.Context, *models.UserSession) ([]contract.FlowInterviewRecord, error) {
	return nil, nil
}

func (*FlowInterviews) GetFlowInterview(context.Context, string, *models.UserSession) (*contract.FlowInterviewRecord, error) {
	return nil, nil
}

func (*FlowInterviews) DeleteFlowInterview(context.Context, string, *models.UserSession) error {
	return nil
}

type FlowAuthoring struct{}

func (*FlowAuthoring) ListFlowDefinitions(context.Context) ([]contract.FlowDefinitionRecord, error) {
	return nil, nil
}

func (*FlowAuthoring) GetFlowDefinition(context.Context, string) (*contract.FlowDefinitionRecord, error) {
	return nil, nil
}

func (*FlowAuthoring) CreateFlowDefinition(context.Context, contract.FlowDefinitionWrite) (*contract.FlowDefinitionCreateResult, error) {
	return nil, nil
}

func (*FlowAuthoring) PatchFlowDefinition(context.Context, string, contract.FlowAdminDefinitionPatchIntent) error {
	return nil
}

func (*FlowAuthoring) DeleteFlowDefinition(context.Context, string) error {
	return nil
}

func (*FlowAuthoring) ListFlowVersions(context.Context, string) ([]contract.FlowVersionRecord, error) {
	return nil, nil
}

func (*FlowAuthoring) GetFlowVersion(context.Context, string) (*contract.FlowVersionRecord, error) {
	return nil, nil
}

func (*FlowAuthoring) CreateFlowVersion(context.Context, contract.FlowVersionWrite) (*contract.FlowVersionCreateResult, error) {
	return nil, nil
}

func (*FlowAuthoring) PatchFlowVersion(context.Context, string, contract.FlowAdminVersionPatchIntent) error {
	return nil
}

func (*FlowAuthoring) DeleteFlowVersion(context.Context, string) error {
	return nil
}

func (*FlowAuthoring) ActivateFlowVersion(context.Context, string) error {
	return nil
}

func (*FlowAuthoring) DeactivateFlowVersion(context.Context, string) error {
	return nil
}

type Approvals struct{}

func (*Approvals) Submit(context.Context, contract.ApprovalSubmitRequest, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*Approvals) Approve(context.Context, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*Approvals) Reject(context.Context, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*Approvals) Recall(context.Context, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*Approvals) Reassign(context.Context, string, string, *models.UserSession) error {
	return nil
}
func (*Approvals) ListPendingApprovals(context.Context, *models.UserSession) ([]contract.ApprovalPendingView, error) {
	return nil, nil
}
func (*Approvals) GetLatestProcessInstance(context.Context, string, *models.UserSession) (*contract.ApprovalProcessInstanceSummary, error) {
	return nil, nil
}
func (*Approvals) GetRecordApprovalStepDisplayMetadata(context.Context, string, *models.UserSession) ([]contract.ApprovalStepDisplayMetadata, error) {
	return nil, nil
}
func (*Approvals) Clone(context.Context, string, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*Approvals) ListApprovalNotificationFlows(context.Context) ([]contract.FlowDescriptor, error) {
	return nil, nil
}

type StandardActions struct{}

func (*StandardActions) ResolveStandardAction(context.Context, string) (*contract.StandardActionResolution, error) {
	return nil, nil
}

func (*StandardActions) AuthorizeResolvedStandardAction(context.Context, *contract.StandardActionRef, *models.UserSession) *contract.StandardActionOutcome {
	return nil
}

func (*StandardActions) ListStandardActions(context.Context, *models.UserSession) ([]contract.StandardActionDescriptor, error) {
	return nil, nil
}

func (*StandardActions) InvokeResolvedStandardAction(context.Context, *contract.StandardActionRef, []map[string]any, *models.UserSession) ([]contract.StandardActionInvocationResult, *contract.StandardActionOutcome) {
	return nil, nil
}

func (*StandardActions) PreviewResolvedRecordCreate(context.Context, *contract.StandardActionRef, map[string]any, *models.UserSession) (*contract.StandardActionPreviewResult, *contract.StandardActionOutcome) {
	return nil, nil
}

func (*StandardActions) PreviewResolvedOutputs(context.Context, *contract.StandardActionRef, string, *models.UserSession) (*contract.StandardActionOutputPreview, *contract.StandardActionOutcome) {
	return nil, nil
}