# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""

import grpc
import warden_pb2 as warden__pb2

GRPC_GENERATED_VERSION = "1.76.0"
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower

    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f"The grpc package installed is at version {GRPC_VERSION},"
        + " but the generated code in warden_pb2_grpc.py depends on"
        + f" grpcio>={GRPC_GENERATED_VERSION}."
        + f" Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}"
        + f" or downgrade your generated code using grpcio-tools<={GRPC_VERSION}."
    )


class WardenServiceStub:
    """============================================================================
    SERVICE DEFINITION (51 ENDPOINTS)
    ============================================================================

    Warden Security Analysis Service
    Provides comprehensive code security analysis, issue tracking, and reporting.
    Port: 50051 | Protocol: gRPC | Total Endpoints: 51
    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.ExecutePipeline = channel.unary_unary(
            "/warden.WardenService/ExecutePipeline",
            request_serializer=warden__pb2.PipelineRequest.SerializeToString,
            response_deserializer=warden__pb2.PipelineResult.FromString,
            _registered_method=True,
        )
        self.ExecutePipelineStream = channel.unary_stream(
            "/warden.WardenService/ExecutePipelineStream",
            request_serializer=warden__pb2.PipelineRequest.SerializeToString,
            response_deserializer=warden__pb2.PipelineEvent.FromString,
            _registered_method=True,
        )
        self.GetAllIssues = channel.unary_unary(
            "/warden.WardenService/GetAllIssues",
            request_serializer=warden__pb2.IssueFilter.SerializeToString,
            response_deserializer=warden__pb2.IssueList.FromString,
            _registered_method=True,
        )
        self.GetOpenIssues = channel.unary_unary(
            "/warden.WardenService/GetOpenIssues",
            request_serializer=warden__pb2.IssueFilter.SerializeToString,
            response_deserializer=warden__pb2.IssueList.FromString,
            _registered_method=True,
        )
        self.GetIssueByHash = channel.unary_unary(
            "/warden.WardenService/GetIssueByHash",
            request_serializer=warden__pb2.IssueHashRequest.SerializeToString,
            response_deserializer=warden__pb2.Issue.FromString,
            _registered_method=True,
        )
        self.ResolveIssue = channel.unary_unary(
            "/warden.WardenService/ResolveIssue",
            request_serializer=warden__pb2.IssueActionRequest.SerializeToString,
            response_deserializer=warden__pb2.IssueActionResponse.FromString,
            _registered_method=True,
        )
        self.SuppressIssue = channel.unary_unary(
            "/warden.WardenService/SuppressIssue",
            request_serializer=warden__pb2.IssueActionRequest.SerializeToString,
            response_deserializer=warden__pb2.IssueActionResponse.FromString,
            _registered_method=True,
        )
        self.ReopenIssue = channel.unary_unary(
            "/warden.WardenService/ReopenIssue",
            request_serializer=warden__pb2.IssueActionRequest.SerializeToString,
            response_deserializer=warden__pb2.IssueActionResponse.FromString,
            _registered_method=True,
        )
        self.GetIssueHistory = channel.unary_unary(
            "/warden.WardenService/GetIssueHistory",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.IssueHistory.FromString,
            _registered_method=True,
        )
        self.GetIssueStats = channel.unary_unary(
            "/warden.WardenService/GetIssueStats",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.IssueStats.FromString,
            _registered_method=True,
        )
        self.AnalyzeResults = channel.unary_unary(
            "/warden.WardenService/AnalyzeResults",
            request_serializer=warden__pb2.AnalyzeResultsRequest.SerializeToString,
            response_deserializer=warden__pb2.AnalysisResult.FromString,
            _registered_method=True,
        )
        self.GetTrends = channel.unary_unary(
            "/warden.WardenService/GetTrends",
            request_serializer=warden__pb2.TrendRequest.SerializeToString,
            response_deserializer=warden__pb2.TrendResponse.FromString,
            _registered_method=True,
        )
        self.GetFrameStats = channel.unary_unary(
            "/warden.WardenService/GetFrameStats",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.FrameStats.FromString,
            _registered_method=True,
        )
        self.GetSeverityStats = channel.unary_unary(
            "/warden.WardenService/GetSeverityStats",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.SeverityStats.FromString,
            _registered_method=True,
        )
        self.GetQualityScore = channel.unary_unary(
            "/warden.WardenService/GetQualityScore",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.QualityScoreResponse.FromString,
            _registered_method=True,
        )
        self.GenerateHtmlReport = channel.unary_unary(
            "/warden.WardenService/GenerateHtmlReport",
            request_serializer=warden__pb2.ReportRequest.SerializeToString,
            response_deserializer=warden__pb2.ReportResponse.FromString,
            _registered_method=True,
        )
        self.GeneratePdfReport = channel.unary_unary(
            "/warden.WardenService/GeneratePdfReport",
            request_serializer=warden__pb2.ReportRequest.SerializeToString,
            response_deserializer=warden__pb2.ReportResponse.FromString,
            _registered_method=True,
        )
        self.GenerateJsonReport = channel.unary_unary(
            "/warden.WardenService/GenerateJsonReport",
            request_serializer=warden__pb2.ReportRequest.SerializeToString,
            response_deserializer=warden__pb2.ReportResponse.FromString,
            _registered_method=True,
        )
        self.GetReportStatus = channel.unary_unary(
            "/warden.WardenService/GetReportStatus",
            request_serializer=warden__pb2.ReportStatusRequest.SerializeToString,
            response_deserializer=warden__pb2.ReportStatusResponse.FromString,
            _registered_method=True,
        )
        self.SearchCode = channel.unary_unary(
            "/warden.WardenService/SearchCode",
            request_serializer=warden__pb2.SearchRequest.SerializeToString,
            response_deserializer=warden__pb2.SearchResult.FromString,
            _registered_method=True,
        )
        self.SearchSimilarCode = channel.unary_unary(
            "/warden.WardenService/SearchSimilarCode",
            request_serializer=warden__pb2.SimilarCodeRequest.SerializeToString,
            response_deserializer=warden__pb2.SearchResult.FromString,
            _registered_method=True,
        )
        self.SearchByDescription = channel.unary_unary(
            "/warden.WardenService/SearchByDescription",
            request_serializer=warden__pb2.SearchRequest.SerializeToString,
            response_deserializer=warden__pb2.SearchResult.FromString,
            _registered_method=True,
        )
        self.IndexProject = channel.unary_unary(
            "/warden.WardenService/IndexProject",
            request_serializer=warden__pb2.IndexRequest.SerializeToString,
            response_deserializer=warden__pb2.IndexResponse.FromString,
            _registered_method=True,
        )
        self.GetIndexStats = channel.unary_unary(
            "/warden.WardenService/GetIndexStats",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.IndexStats.FromString,
            _registered_method=True,
        )
        self.ClearIndex = channel.unary_unary(
            "/warden.WardenService/ClearIndex",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.IndexResponse.FromString,
            _registered_method=True,
        )
        self.DiscoverFiles = channel.unary_unary(
            "/warden.WardenService/DiscoverFiles",
            request_serializer=warden__pb2.DiscoverRequest.SerializeToString,
            response_deserializer=warden__pb2.DiscoverResponse.FromString,
            _registered_method=True,
        )
        self.GetFilesByType = channel.unary_unary(
            "/warden.WardenService/GetFilesByType",
            request_serializer=warden__pb2.FileTypeFilter.SerializeToString,
            response_deserializer=warden__pb2.DiscoverResponse.FromString,
            _registered_method=True,
        )
        self.DetectFrameworks = channel.unary_unary(
            "/warden.WardenService/DetectFrameworks",
            request_serializer=warden__pb2.DiscoverRequest.SerializeToString,
            response_deserializer=warden__pb2.DiscoverResponse.FromString,
            _registered_method=True,
        )
        self.GetProjectStats = channel.unary_unary(
            "/warden.WardenService/GetProjectStats",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.ProjectStats.FromString,
            _registered_method=True,
        )
        self.AnalyzeWithLlm = channel.unary_unary(
            "/warden.WardenService/AnalyzeWithLlm",
            request_serializer=warden__pb2.LlmAnalyzeRequest.SerializeToString,
            response_deserializer=warden__pb2.LlmAnalyzeResult.FromString,
            _registered_method=True,
        )
        self.ClassifyCode = channel.unary_unary(
            "/warden.WardenService/ClassifyCode",
            request_serializer=warden__pb2.ClassifyRequest.SerializeToString,
            response_deserializer=warden__pb2.ClassifyResult.FromString,
            _registered_method=True,
        )
        self.TestLlmProvider = channel.unary_unary(
            "/warden.WardenService/TestLlmProvider",
            request_serializer=warden__pb2.TestProviderRequest.SerializeToString,
            response_deserializer=warden__pb2.TestProviderResponse.FromString,
            _registered_method=True,
        )
        self.GetAvailableModels = channel.unary_unary(
            "/warden.WardenService/GetAvailableModels",
            request_serializer=warden__pb2.AvailableModelsRequest.SerializeToString,
            response_deserializer=warden__pb2.AvailableModelsResponse.FromString,
            _registered_method=True,
        )
        self.ValidateLlmConfig = channel.unary_unary(
            "/warden.WardenService/ValidateLlmConfig",
            request_serializer=warden__pb2.ValidateLlmConfigRequest.SerializeToString,
            response_deserializer=warden__pb2.ValidateLlmConfigResponse.FromString,
            _registered_method=True,
        )
        self.AnalyzeCleanup = channel.unary_unary(
            "/warden.WardenService/AnalyzeCleanup",
            request_serializer=warden__pb2.CleanupRequest.SerializeToString,
            response_deserializer=warden__pb2.CleanupResult.FromString,
            _registered_method=True,
        )
        self.GetCleanupSuggestions = channel.unary_unary(
            "/warden.WardenService/GetCleanupSuggestions",
            request_serializer=warden__pb2.CleanupRequest.SerializeToString,
            response_deserializer=warden__pb2.CleanupResult.FromString,
            _registered_method=True,
        )
        self.GetCleanupScore = channel.unary_unary(
            "/warden.WardenService/GetCleanupScore",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.CleanupScoreResponse.FromString,
            _registered_method=True,
        )
        self.GetFortificationSuggestions = channel.unary_unary(
            "/warden.WardenService/GetFortificationSuggestions",
            request_serializer=warden__pb2.FortificationRequest.SerializeToString,
            response_deserializer=warden__pb2.FortificationResult.FromString,
            _registered_method=True,
        )
        self.ApplyFortification = channel.unary_unary(
            "/warden.WardenService/ApplyFortification",
            request_serializer=warden__pb2.ApplyFortificationRequest.SerializeToString,
            response_deserializer=warden__pb2.ApplyFortificationResponse.FromString,
            _registered_method=True,
        )
        self.GetSecurityScore = channel.unary_unary(
            "/warden.WardenService/GetSecurityScore",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.SecurityScoreResponse.FromString,
            _registered_method=True,
        )
        self.AddSuppression = channel.unary_unary(
            "/warden.WardenService/AddSuppression",
            request_serializer=warden__pb2.AddSuppressionRequest.SerializeToString,
            response_deserializer=warden__pb2.AddSuppressionResponse.FromString,
            _registered_method=True,
        )
        self.RemoveSuppression = channel.unary_unary(
            "/warden.WardenService/RemoveSuppression",
            request_serializer=warden__pb2.RemoveSuppressionRequest.SerializeToString,
            response_deserializer=warden__pb2.RemoveSuppressionResponse.FromString,
            _registered_method=True,
        )
        self.GetSuppressions = channel.unary_unary(
            "/warden.WardenService/GetSuppressions",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.SuppressionList.FromString,
            _registered_method=True,
        )
        self.CheckSuppression = channel.unary_unary(
            "/warden.WardenService/CheckSuppression",
            request_serializer=warden__pb2.CheckSuppressionRequest.SerializeToString,
            response_deserializer=warden__pb2.CheckSuppressionResponse.FromString,
            _registered_method=True,
        )
        self.GetAvailableFrames = channel.unary_unary(
            "/warden.WardenService/GetAvailableFrames",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.FrameList.FromString,
            _registered_method=True,
        )
        self.GetAvailableProviders = channel.unary_unary(
            "/warden.WardenService/GetAvailableProviders",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.ProviderList.FromString,
            _registered_method=True,
        )
        self.GetConfiguration = channel.unary_unary(
            "/warden.WardenService/GetConfiguration",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.ConfigurationResponse.FromString,
            _registered_method=True,
        )
        self.UpdateConfiguration = channel.unary_unary(
            "/warden.WardenService/UpdateConfiguration",
            request_serializer=warden__pb2.UpdateConfigRequest.SerializeToString,
            response_deserializer=warden__pb2.UpdateConfigResponse.FromString,
            _registered_method=True,
        )
        self.UpdateFrameStatus = channel.unary_unary(
            "/warden.WardenService/UpdateFrameStatus",
            request_serializer=warden__pb2.UpdateFrameStatusRequest.SerializeToString,
            response_deserializer=warden__pb2.UpdateFrameStatusResponse.FromString,
            _registered_method=True,
        )
        self.HealthCheck = channel.unary_unary(
            "/warden.WardenService/HealthCheck",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.HealthResponse.FromString,
            _registered_method=True,
        )
        self.GetStatus = channel.unary_unary(
            "/warden.WardenService/GetStatus",
            request_serializer=warden__pb2.Empty.SerializeToString,
            response_deserializer=warden__pb2.StatusResponse.FromString,
            _registered_method=True,
        )


class WardenServiceServicer:
    """============================================================================
    SERVICE DEFINITION (51 ENDPOINTS)
    ============================================================================

    Warden Security Analysis Service
    Provides comprehensive code security analysis, issue tracking, and reporting.
    Port: 50051 | Protocol: gRPC | Total Endpoints: 51
    """

    def ExecutePipeline(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        PIPELINE OPERATIONS (2 endpoints)
        Execute security validation pipelines on code
        ═══════════════════════════════════════════════════════════════════════

        Execute full security validation pipeline on specified path.
        Runs all enabled validation frames and returns findings, fortifications, and cleanings.
        Use 'frames' field to run specific frames only.
        Returns: PipelineResult with all findings and execution metrics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ExecutePipelineStream(self, request, context):
        """Execute pipeline with real-time streaming progress events.
        Ideal for long-running scans - receive findings as they're discovered.
        Events: pipeline_start, frame_start, finding, frame_complete, pipeline_complete, error.
        Returns: Stream of PipelineEvent messages.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAllIssues(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        ISSUE MANAGEMENT (8 endpoints)
        Track, manage, and resolve security issues
        ═══════════════════════════════════════════════════════════════════════

        Get all tracked issues with optional filtering.
        Supports filtering by: state (OPEN, RESOLVED, SUPPRESSED), severity, frame_id, file_path.
        Supports pagination via limit/offset.
        Returns: IssueList with total_count and filtered_count.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetOpenIssues(self, request, context):
        """Get only OPEN issues (convenience method).
        Same filtering capabilities as GetAllIssues, but pre-filtered to OPEN state.
        Returns: IssueList containing only open issues.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetIssueByHash(self, request, context):
        """Get a specific issue by its content hash.
        Hash is SHA256(title + file_path + line_number)[:16].
        Use for deduplication and tracking recurring issues.
        Returns: Issue if found, NOT_FOUND error otherwise.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ResolveIssue(self, request, context):
        """Mark an issue as resolved.
        Requires issue_id and actor (who resolved it).
        Sets state to RESOLVED and records resolved_at timestamp.
        Returns: IssueActionResponse with updated issue.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SuppressIssue(self, request, context):
        """Mark an issue as suppressed (false positive).
        Requires issue_id, actor, and comment (justification).
        Suppressed issues won't appear in open issues list.
        Returns: IssueActionResponse with updated issue.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ReopenIssue(self, request, context):
        """Reopen a resolved or suppressed issue.
        Sets state to REOPENED and clears resolved_at/suppressed_at.
        Use when an issue resurfaces or suppression was incorrect.
        Returns: IssueActionResponse with updated issue.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetIssueHistory(self, request, context):
        """Get historical issue snapshots.
        Returns last 50 snapshots showing issue counts over time.
        Useful for trend analysis and reporting.
        Returns: IssueHistory with list of IssueSnapshot.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetIssueStats(self, request, context):
        """Get aggregated issue statistics.
        Includes: totals by state, severity counts, issues by frame, top 10 files.
        Returns: IssueStats with comprehensive breakdown.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def AnalyzeResults(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        RESULT ANALYSIS (5 endpoints)
        Analyze trends and quality metrics
        ═══════════════════════════════════════════════════════════════════════

        Analyze pipeline results for trends and quality.
        Compares with previous runs to identify new/resolved issues.
        Calculates quality_score (0-100) and trend direction.
        Returns: AnalysisResult with metrics and trend analysis.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetTrends(self, request, context):
        """Get trend data over time.
        Shows issue count and quality score progression.
        Use 'limit' to specify number of data points (default: 10).
        Returns: TrendResponse with overall_trend and data points.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetFrameStats(self, request, context):
        """Get statistics grouped by validation frame.
        Shows findings count and severity breakdown per frame.
        Useful for identifying problematic areas.
        Returns: FrameStats with per-frame metrics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSeverityStats(self, request, context):
        """Get severity distribution statistics.
        Shows count of issues by severity level.
        Includes weighted_score for prioritization.
        Returns: SeverityStats with counts and weighted score.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetQualityScore(self, request, context):
        """Get overall code quality score.
        Score: 0-100 based on weighted severity of open issues.
        Grade: A (90+), B (80+), C (70+), D (60+), F (<60).
        Returns: QualityScoreResponse with score, grade, and category breakdown.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GenerateHtmlReport(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        REPORT GENERATION (4 endpoints)
        Generate security reports in various formats
        ═══════════════════════════════════════════════════════════════════════

        Generate HTML security report.
        Creates a styled, interactive HTML report with all issues.
        Specify output_path or let server generate temp file.
        Returns: ReportResponse with file_path and size_bytes.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GeneratePdfReport(self, request, context):
        """Generate PDF security report.
        Requires wkhtmltopdf installed on server.
        Creates professional PDF suitable for stakeholders.
        Returns: ReportResponse with file_path (or error if unavailable).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GenerateJsonReport(self, request, context):
        """Generate JSON report for integration.
        Machine-readable format with all issues and metadata.
        Can be used for CI/CD integration or data export.
        Returns: ReportResponse with content (JSON string) or file_path.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetReportStatus(self, request, context):
        """Check status of async report generation.
        For long-running reports, poll this endpoint.
        Status: pending, generating, completed, failed.
        Returns: ReportStatusResponse with progress (0.0-1.0).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SearchCode(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        SEMANTIC SEARCH (6 endpoints)
        AI-powered code search using embeddings
        ═══════════════════════════════════════════════════════════════════════

        Search code using semantic similarity.
        Query can be natural language or code snippet.
        Filter by language, limit results, set min_score threshold.
        Returns: SearchResult with matching CodeChunks and similarity scores.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SearchSimilarCode(self, request, context):
        """Find code similar to given snippet.
        Uses code embeddings to find structurally similar code.
        Useful for finding duplicate or related code patterns.
        Returns: SearchResult with similar CodeChunks ranked by similarity.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SearchByDescription(self, request, context):
        """Search code using natural language description.
        Example: "function that validates email addresses"
        Optimized for descriptive queries vs code queries.
        Returns: SearchResult with matching CodeChunks.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def IndexProject(self, request, context):
        """Index project for semantic search.
        Creates embeddings for all code chunks (functions, classes, methods).
        Set force_reindex=true to rebuild entire index.
        Returns: IndexResponse with files_indexed and chunks_created.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetIndexStats(self, request, context):
        """Get semantic search index statistics.
        Shows total files, chunks, breakdown by language/type.
        Includes last_indexed timestamp and index_size_bytes.
        Returns: IndexStats with comprehensive index metrics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ClearIndex(self, request, context):
        """Clear semantic search index.
        Removes all indexed data. Use before full reindex.
        Caution: SearchCode will return no results until reindexed.
        Returns: IndexResponse indicating success.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DiscoverFiles(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        FILE DISCOVERY (4 endpoints)
        Discover and analyze project files
        ═══════════════════════════════════════════════════════════════════════

        Discover all project files.
        Recursively scans directory, respects .gitignore if use_gitignore=true.
        Returns file list with type detection and analyzability flag.
        Returns: DiscoverResponse with files, frameworks, and stats.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetFilesByType(self, request, context):
        """Get files filtered by programming language type.
        Specify types: PYTHON, JAVASCRIPT, TYPESCRIPT, JAVA, CSHARP, etc.
        More efficient than DiscoverFiles when you know target languages.
        Returns: DiscoverResponse with filtered file list.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DetectFrameworks(self, request, context):
        """Detect frameworks and libraries used in project.
        Analyzes package.json, requirements.txt, Cargo.toml, etc.
        Returns framework names, versions, and detection confidence.
        Returns: DiscoverResponse with frameworks list.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetProjectStats(self, request, context):
        """Get project-wide statistics.
        Total files, total lines, size breakdown by language.
        Useful for project overview and capacity planning.
        Returns: ProjectStats with comprehensive metrics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def AnalyzeWithLlm(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        LLM OPERATIONS (5 endpoints)
        AI-powered code analysis using language models
        ═══════════════════════════════════════════════════════════════════════

        Analyze code with LLM (AI assistant).
        Send code and custom prompt for analysis.
        Supports multiple providers: anthropic, openai, ollama.
        Returns: LlmAnalyzeResult with AI response and metrics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ClassifyCode(self, request, context):
        """Classify code to recommend validation frames.
        Detects: async ops, user input, database, network, file ops, auth, crypto.
        Returns recommended frames based on code characteristics.
        Returns: ClassifyResult with flags and recommendations.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def TestLlmProvider(self, request, context):
        """Test LLM provider connectivity.
        Sends test prompt and measures response latency.
        Use to verify API keys and network connectivity.
        Returns: TestProviderResponse with success, model, and latency_ms.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAvailableModels(self, request, context):
        """Get available models for a provider.
        Lists models with max_tokens and availability status.
        Provider: "anthropic", "openai", "ollama".
        Returns: AvailableModelsResponse with model list.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ValidateLlmConfig(self, request, context):
        """Validate LLM configuration.
        Checks API keys, model availability, and settings.
        Returns errors (blocking) and warnings (informational).
        Returns: ValidateLlmConfigResponse with valid flag and messages.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def AnalyzeCleanup(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        CLEANUP ANALYSIS (3 endpoints)
        Code quality and cleanup suggestions
        ═══════════════════════════════════════════════════════════════════════

        Analyze code for cleanup opportunities.
        Checks: naming conventions, complexity, duplication, magic numbers.
        Specify analyzers or leave empty for all.
        Returns: CleanupResult with suggestions and cleanup_score.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetCleanupSuggestions(self, request, context):
        """Get cleanup suggestions (alias for AnalyzeCleanup).
        Convenience method with same functionality.
        Returns: CleanupResult with prioritized suggestions.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetCleanupScore(self, request, context):
        """Get overall code cleanup score.
        Score: 0-100 based on code cleanliness.
        Includes per-analyzer scores and letter grade.
        Returns: CleanupScoreResponse with score breakdown.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetFortificationSuggestions(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        FORTIFICATION (3 endpoints)
        Security hardening suggestions
        ═══════════════════════════════════════════════════════════════════════

        Get security fortification suggestions.
        Identifies: missing input validation, weak error handling, etc.
        Provides original_code and suggested_code with rationale.
        Returns: FortificationResult with suggestions and security_score.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ApplyFortification(self, request, context):
        """Apply a fortification suggestion.
        Set dry_run=true to preview changes without modifying files.
        Returns unified diff showing proposed changes.
        Returns: ApplyFortificationResponse with diff and file_path.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSecurityScore(self, request, context):
        """Get overall security score.
        Score: 0-100 based on security vulnerabilities.
        Includes category scores: authentication, authorization, injection, crypto.
        Returns: SecurityScoreResponse with score and vulnerability list.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def AddSuppression(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        SUPPRESSION (4 endpoints)
        Manage false positive suppressions
        ═══════════════════════════════════════════════════════════════════════

        Add a suppression rule for false positives.
        Can be global (is_global=true) or file/line specific.
        Requires justification for audit trail.
        Returns: AddSuppressionResponse with created suppression.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RemoveSuppression(self, request, context):
        """Remove a suppression rule.
        Use suppression_id from AddSuppression or GetSuppressions.
        Removed rules no longer apply to future scans.
        Returns: RemoveSuppressionResponse indicating success.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSuppressions(self, request, context):
        """Get all active suppression rules.
        Lists all suppressions with their justifications.
        Use for auditing and management.
        Returns: SuppressionList with all rules.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def CheckSuppression(self, request, context):
        """Check if an issue matches a suppression rule.
        Checks global rules first, then file-specific.
        Returns matching suppression if found.
        Returns: CheckSuppressionResponse with is_suppressed flag.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAvailableFrames(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        CONFIGURATION (5 endpoints)
        Server and frame configuration
        ═══════════════════════════════════════════════════════════════════════

        Get list of available validation frames.
        Each frame validates specific security aspects.
        Shows: id, name, description, priority, enabled status.
        Returns: FrameList with all registered frames.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAvailableProviders(self, request, context):
        """Get list of available LLM providers.
        Shows configured providers and their availability.
        Includes default_provider selection.
        Returns: ProviderList with provider details.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetConfiguration(self, request, context):
        """Get complete server configuration.
        Includes: project_root, config_file, active_profile.
        Also includes available_frames and available_providers.
        Returns: ConfigurationResponse with full config.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateConfiguration(self, request, context):
        """Update server configuration settings.
        Pass key-value pairs in settings map.
        Changes take effect immediately.
        Returns: UpdateConfigResponse indicating success.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateFrameStatus(self, request, context):
        """Enable or disable a validation frame.
        Use frame_id from GetAvailableFrames.
        Disabled frames won't run in pipeline execution.
        Returns: UpdateFrameStatusResponse with updated frame.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def HealthCheck(self, request, context):
        """═══════════════════════════════════════════════════════════════════════
        HEALTH & STATUS (2 endpoints)
        Server health monitoring
        ═══════════════════════════════════════════════════════════════════════

        Health check endpoint.
        Returns healthy=true if all components are operational.
        Components checked: bridge, orchestrator, llm.
        Returns: HealthResponse with health status and uptime.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetStatus(self, request, context):
        """Get detailed server status.
        Shows: running state, active pipelines, scan counts.
        Includes resource usage: memory_mb, cpu_percent.
        Returns: StatusResponse with runtime metrics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")


def add_WardenServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
        "ExecutePipeline": grpc.unary_unary_rpc_method_handler(
            servicer.ExecutePipeline,
            request_deserializer=warden__pb2.PipelineRequest.FromString,
            response_serializer=warden__pb2.PipelineResult.SerializeToString,
        ),
        "ExecutePipelineStream": grpc.unary_stream_rpc_method_handler(
            servicer.ExecutePipelineStream,
            request_deserializer=warden__pb2.PipelineRequest.FromString,
            response_serializer=warden__pb2.PipelineEvent.SerializeToString,
        ),
        "GetAllIssues": grpc.unary_unary_rpc_method_handler(
            servicer.GetAllIssues,
            request_deserializer=warden__pb2.IssueFilter.FromString,
            response_serializer=warden__pb2.IssueList.SerializeToString,
        ),
        "GetOpenIssues": grpc.unary_unary_rpc_method_handler(
            servicer.GetOpenIssues,
            request_deserializer=warden__pb2.IssueFilter.FromString,
            response_serializer=warden__pb2.IssueList.SerializeToString,
        ),
        "GetIssueByHash": grpc.unary_unary_rpc_method_handler(
            servicer.GetIssueByHash,
            request_deserializer=warden__pb2.IssueHashRequest.FromString,
            response_serializer=warden__pb2.Issue.SerializeToString,
        ),
        "ResolveIssue": grpc.unary_unary_rpc_method_handler(
            servicer.ResolveIssue,
            request_deserializer=warden__pb2.IssueActionRequest.FromString,
            response_serializer=warden__pb2.IssueActionResponse.SerializeToString,
        ),
        "SuppressIssue": grpc.unary_unary_rpc_method_handler(
            servicer.SuppressIssue,
            request_deserializer=warden__pb2.IssueActionRequest.FromString,
            response_serializer=warden__pb2.IssueActionResponse.SerializeToString,
        ),
        "ReopenIssue": grpc.unary_unary_rpc_method_handler(
            servicer.ReopenIssue,
            request_deserializer=warden__pb2.IssueActionRequest.FromString,
            response_serializer=warden__pb2.IssueActionResponse.SerializeToString,
        ),
        "GetIssueHistory": grpc.unary_unary_rpc_method_handler(
            servicer.GetIssueHistory,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.IssueHistory.SerializeToString,
        ),
        "GetIssueStats": grpc.unary_unary_rpc_method_handler(
            servicer.GetIssueStats,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.IssueStats.SerializeToString,
        ),
        "AnalyzeResults": grpc.unary_unary_rpc_method_handler(
            servicer.AnalyzeResults,
            request_deserializer=warden__pb2.AnalyzeResultsRequest.FromString,
            response_serializer=warden__pb2.AnalysisResult.SerializeToString,
        ),
        "GetTrends": grpc.unary_unary_rpc_method_handler(
            servicer.GetTrends,
            request_deserializer=warden__pb2.TrendRequest.FromString,
            response_serializer=warden__pb2.TrendResponse.SerializeToString,
        ),
        "GetFrameStats": grpc.unary_unary_rpc_method_handler(
            servicer.GetFrameStats,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.FrameStats.SerializeToString,
        ),
        "GetSeverityStats": grpc.unary_unary_rpc_method_handler(
            servicer.GetSeverityStats,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.SeverityStats.SerializeToString,
        ),
        "GetQualityScore": grpc.unary_unary_rpc_method_handler(
            servicer.GetQualityScore,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.QualityScoreResponse.SerializeToString,
        ),
        "GenerateHtmlReport": grpc.unary_unary_rpc_method_handler(
            servicer.GenerateHtmlReport,
            request_deserializer=warden__pb2.ReportRequest.FromString,
            response_serializer=warden__pb2.ReportResponse.SerializeToString,
        ),
        "GeneratePdfReport": grpc.unary_unary_rpc_method_handler(
            servicer.GeneratePdfReport,
            request_deserializer=warden__pb2.ReportRequest.FromString,
            response_serializer=warden__pb2.ReportResponse.SerializeToString,
        ),
        "GenerateJsonReport": grpc.unary_unary_rpc_method_handler(
            servicer.GenerateJsonReport,
            request_deserializer=warden__pb2.ReportRequest.FromString,
            response_serializer=warden__pb2.ReportResponse.SerializeToString,
        ),
        "GetReportStatus": grpc.unary_unary_rpc_method_handler(
            servicer.GetReportStatus,
            request_deserializer=warden__pb2.ReportStatusRequest.FromString,
            response_serializer=warden__pb2.ReportStatusResponse.SerializeToString,
        ),
        "SearchCode": grpc.unary_unary_rpc_method_handler(
            servicer.SearchCode,
            request_deserializer=warden__pb2.SearchRequest.FromString,
            response_serializer=warden__pb2.SearchResult.SerializeToString,
        ),
        "SearchSimilarCode": grpc.unary_unary_rpc_method_handler(
            servicer.SearchSimilarCode,
            request_deserializer=warden__pb2.SimilarCodeRequest.FromString,
            response_serializer=warden__pb2.SearchResult.SerializeToString,
        ),
        "SearchByDescription": grpc.unary_unary_rpc_method_handler(
            servicer.SearchByDescription,
            request_deserializer=warden__pb2.SearchRequest.FromString,
            response_serializer=warden__pb2.SearchResult.SerializeToString,
        ),
        "IndexProject": grpc.unary_unary_rpc_method_handler(
            servicer.IndexProject,
            request_deserializer=warden__pb2.IndexRequest.FromString,
            response_serializer=warden__pb2.IndexResponse.SerializeToString,
        ),
        "GetIndexStats": grpc.unary_unary_rpc_method_handler(
            servicer.GetIndexStats,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.IndexStats.SerializeToString,
        ),
        "ClearIndex": grpc.unary_unary_rpc_method_handler(
            servicer.ClearIndex,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.IndexResponse.SerializeToString,
        ),
        "DiscoverFiles": grpc.unary_unary_rpc_method_handler(
            servicer.DiscoverFiles,
            request_deserializer=warden__pb2.DiscoverRequest.FromString,
            response_serializer=warden__pb2.DiscoverResponse.SerializeToString,
        ),
        "GetFilesByType": grpc.unary_unary_rpc_method_handler(
            servicer.GetFilesByType,
            request_deserializer=warden__pb2.FileTypeFilter.FromString,
            response_serializer=warden__pb2.DiscoverResponse.SerializeToString,
        ),
        "DetectFrameworks": grpc.unary_unary_rpc_method_handler(
            servicer.DetectFrameworks,
            request_deserializer=warden__pb2.DiscoverRequest.FromString,
            response_serializer=warden__pb2.DiscoverResponse.SerializeToString,
        ),
        "GetProjectStats": grpc.unary_unary_rpc_method_handler(
            servicer.GetProjectStats,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.ProjectStats.SerializeToString,
        ),
        "AnalyzeWithLlm": grpc.unary_unary_rpc_method_handler(
            servicer.AnalyzeWithLlm,
            request_deserializer=warden__pb2.LlmAnalyzeRequest.FromString,
            response_serializer=warden__pb2.LlmAnalyzeResult.SerializeToString,
        ),
        "ClassifyCode": grpc.unary_unary_rpc_method_handler(
            servicer.ClassifyCode,
            request_deserializer=warden__pb2.ClassifyRequest.FromString,
            response_serializer=warden__pb2.ClassifyResult.SerializeToString,
        ),
        "TestLlmProvider": grpc.unary_unary_rpc_method_handler(
            servicer.TestLlmProvider,
            request_deserializer=warden__pb2.TestProviderRequest.FromString,
            response_serializer=warden__pb2.TestProviderResponse.SerializeToString,
        ),
        "GetAvailableModels": grpc.unary_unary_rpc_method_handler(
            servicer.GetAvailableModels,
            request_deserializer=warden__pb2.AvailableModelsRequest.FromString,
            response_serializer=warden__pb2.AvailableModelsResponse.SerializeToString,
        ),
        "ValidateLlmConfig": grpc.unary_unary_rpc_method_handler(
            servicer.ValidateLlmConfig,
            request_deserializer=warden__pb2.ValidateLlmConfigRequest.FromString,
            response_serializer=warden__pb2.ValidateLlmConfigResponse.SerializeToString,
        ),
        "AnalyzeCleanup": grpc.unary_unary_rpc_method_handler(
            servicer.AnalyzeCleanup,
            request_deserializer=warden__pb2.CleanupRequest.FromString,
            response_serializer=warden__pb2.CleanupResult.SerializeToString,
        ),
        "GetCleanupSuggestions": grpc.unary_unary_rpc_method_handler(
            servicer.GetCleanupSuggestions,
            request_deserializer=warden__pb2.CleanupRequest.FromString,
            response_serializer=warden__pb2.CleanupResult.SerializeToString,
        ),
        "GetCleanupScore": grpc.unary_unary_rpc_method_handler(
            servicer.GetCleanupScore,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.CleanupScoreResponse.SerializeToString,
        ),
        "GetFortificationSuggestions": grpc.unary_unary_rpc_method_handler(
            servicer.GetFortificationSuggestions,
            request_deserializer=warden__pb2.FortificationRequest.FromString,
            response_serializer=warden__pb2.FortificationResult.SerializeToString,
        ),
        "ApplyFortification": grpc.unary_unary_rpc_method_handler(
            servicer.ApplyFortification,
            request_deserializer=warden__pb2.ApplyFortificationRequest.FromString,
            response_serializer=warden__pb2.ApplyFortificationResponse.SerializeToString,
        ),
        "GetSecurityScore": grpc.unary_unary_rpc_method_handler(
            servicer.GetSecurityScore,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.SecurityScoreResponse.SerializeToString,
        ),
        "AddSuppression": grpc.unary_unary_rpc_method_handler(
            servicer.AddSuppression,
            request_deserializer=warden__pb2.AddSuppressionRequest.FromString,
            response_serializer=warden__pb2.AddSuppressionResponse.SerializeToString,
        ),
        "RemoveSuppression": grpc.unary_unary_rpc_method_handler(
            servicer.RemoveSuppression,
            request_deserializer=warden__pb2.RemoveSuppressionRequest.FromString,
            response_serializer=warden__pb2.RemoveSuppressionResponse.SerializeToString,
        ),
        "GetSuppressions": grpc.unary_unary_rpc_method_handler(
            servicer.GetSuppressions,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.SuppressionList.SerializeToString,
        ),
        "CheckSuppression": grpc.unary_unary_rpc_method_handler(
            servicer.CheckSuppression,
            request_deserializer=warden__pb2.CheckSuppressionRequest.FromString,
            response_serializer=warden__pb2.CheckSuppressionResponse.SerializeToString,
        ),
        "GetAvailableFrames": grpc.unary_unary_rpc_method_handler(
            servicer.GetAvailableFrames,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.FrameList.SerializeToString,
        ),
        "GetAvailableProviders": grpc.unary_unary_rpc_method_handler(
            servicer.GetAvailableProviders,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.ProviderList.SerializeToString,
        ),
        "GetConfiguration": grpc.unary_unary_rpc_method_handler(
            servicer.GetConfiguration,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.ConfigurationResponse.SerializeToString,
        ),
        "UpdateConfiguration": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateConfiguration,
            request_deserializer=warden__pb2.UpdateConfigRequest.FromString,
            response_serializer=warden__pb2.UpdateConfigResponse.SerializeToString,
        ),
        "UpdateFrameStatus": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateFrameStatus,
            request_deserializer=warden__pb2.UpdateFrameStatusRequest.FromString,
            response_serializer=warden__pb2.UpdateFrameStatusResponse.SerializeToString,
        ),
        "HealthCheck": grpc.unary_unary_rpc_method_handler(
            servicer.HealthCheck,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.HealthResponse.SerializeToString,
        ),
        "GetStatus": grpc.unary_unary_rpc_method_handler(
            servicer.GetStatus,
            request_deserializer=warden__pb2.Empty.FromString,
            response_serializer=warden__pb2.StatusResponse.SerializeToString,
        ),
    }
    generic_handler = grpc.method_handlers_generic_handler("warden.WardenService", rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers("warden.WardenService", rpc_method_handlers)


# This class is part of an EXPERIMENTAL API.
class WardenService:
    """============================================================================
    SERVICE DEFINITION (51 ENDPOINTS)
    ============================================================================

    Warden Security Analysis Service
    Provides comprehensive code security analysis, issue tracking, and reporting.
    Port: 50051 | Protocol: gRPC | Total Endpoints: 51
    """

    @staticmethod
    def ExecutePipeline(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/ExecutePipeline",
            warden__pb2.PipelineRequest.SerializeToString,
            warden__pb2.PipelineResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ExecutePipelineStream(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/warden.WardenService/ExecutePipelineStream",
            warden__pb2.PipelineRequest.SerializeToString,
            warden__pb2.PipelineEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetAllIssues(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetAllIssues",
            warden__pb2.IssueFilter.SerializeToString,
            warden__pb2.IssueList.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetOpenIssues(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetOpenIssues",
            warden__pb2.IssueFilter.SerializeToString,
            warden__pb2.IssueList.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetIssueByHash(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetIssueByHash",
            warden__pb2.IssueHashRequest.SerializeToString,
            warden__pb2.Issue.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ResolveIssue(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/ResolveIssue",
            warden__pb2.IssueActionRequest.SerializeToString,
            warden__pb2.IssueActionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def SuppressIssue(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/SuppressIssue",
            warden__pb2.IssueActionRequest.SerializeToString,
            warden__pb2.IssueActionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ReopenIssue(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/ReopenIssue",
            warden__pb2.IssueActionRequest.SerializeToString,
            warden__pb2.IssueActionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetIssueHistory(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetIssueHistory",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.IssueHistory.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetIssueStats(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetIssueStats",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.IssueStats.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def AnalyzeResults(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/AnalyzeResults",
            warden__pb2.AnalyzeResultsRequest.SerializeToString,
            warden__pb2.AnalysisResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetTrends(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetTrends",
            warden__pb2.TrendRequest.SerializeToString,
            warden__pb2.TrendResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetFrameStats(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetFrameStats",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.FrameStats.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetSeverityStats(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetSeverityStats",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.SeverityStats.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetQualityScore(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetQualityScore",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.QualityScoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GenerateHtmlReport(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GenerateHtmlReport",
            warden__pb2.ReportRequest.SerializeToString,
            warden__pb2.ReportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GeneratePdfReport(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GeneratePdfReport",
            warden__pb2.ReportRequest.SerializeToString,
            warden__pb2.ReportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GenerateJsonReport(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GenerateJsonReport",
            warden__pb2.ReportRequest.SerializeToString,
            warden__pb2.ReportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetReportStatus(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetReportStatus",
            warden__pb2.ReportStatusRequest.SerializeToString,
            warden__pb2.ReportStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def SearchCode(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/SearchCode",
            warden__pb2.SearchRequest.SerializeToString,
            warden__pb2.SearchResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def SearchSimilarCode(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/SearchSimilarCode",
            warden__pb2.SimilarCodeRequest.SerializeToString,
            warden__pb2.SearchResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def SearchByDescription(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/SearchByDescription",
            warden__pb2.SearchRequest.SerializeToString,
            warden__pb2.SearchResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def IndexProject(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/IndexProject",
            warden__pb2.IndexRequest.SerializeToString,
            warden__pb2.IndexResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetIndexStats(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetIndexStats",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.IndexStats.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ClearIndex(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/ClearIndex",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.IndexResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def DiscoverFiles(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/DiscoverFiles",
            warden__pb2.DiscoverRequest.SerializeToString,
            warden__pb2.DiscoverResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetFilesByType(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetFilesByType",
            warden__pb2.FileTypeFilter.SerializeToString,
            warden__pb2.DiscoverResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def DetectFrameworks(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/DetectFrameworks",
            warden__pb2.DiscoverRequest.SerializeToString,
            warden__pb2.DiscoverResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetProjectStats(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetProjectStats",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.ProjectStats.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def AnalyzeWithLlm(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/AnalyzeWithLlm",
            warden__pb2.LlmAnalyzeRequest.SerializeToString,
            warden__pb2.LlmAnalyzeResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ClassifyCode(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/ClassifyCode",
            warden__pb2.ClassifyRequest.SerializeToString,
            warden__pb2.ClassifyResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def TestLlmProvider(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/TestLlmProvider",
            warden__pb2.TestProviderRequest.SerializeToString,
            warden__pb2.TestProviderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetAvailableModels(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetAvailableModels",
            warden__pb2.AvailableModelsRequest.SerializeToString,
            warden__pb2.AvailableModelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ValidateLlmConfig(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/ValidateLlmConfig",
            warden__pb2.ValidateLlmConfigRequest.SerializeToString,
            warden__pb2.ValidateLlmConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def AnalyzeCleanup(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/AnalyzeCleanup",
            warden__pb2.CleanupRequest.SerializeToString,
            warden__pb2.CleanupResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetCleanupSuggestions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetCleanupSuggestions",
            warden__pb2.CleanupRequest.SerializeToString,
            warden__pb2.CleanupResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetCleanupScore(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetCleanupScore",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.CleanupScoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetFortificationSuggestions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetFortificationSuggestions",
            warden__pb2.FortificationRequest.SerializeToString,
            warden__pb2.FortificationResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ApplyFortification(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/ApplyFortification",
            warden__pb2.ApplyFortificationRequest.SerializeToString,
            warden__pb2.ApplyFortificationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetSecurityScore(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetSecurityScore",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.SecurityScoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def AddSuppression(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/AddSuppression",
            warden__pb2.AddSuppressionRequest.SerializeToString,
            warden__pb2.AddSuppressionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def RemoveSuppression(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/RemoveSuppression",
            warden__pb2.RemoveSuppressionRequest.SerializeToString,
            warden__pb2.RemoveSuppressionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetSuppressions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetSuppressions",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.SuppressionList.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def CheckSuppression(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/CheckSuppression",
            warden__pb2.CheckSuppressionRequest.SerializeToString,
            warden__pb2.CheckSuppressionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetAvailableFrames(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetAvailableFrames",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.FrameList.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetAvailableProviders(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetAvailableProviders",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.ProviderList.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetConfiguration(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetConfiguration",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.ConfigurationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def UpdateConfiguration(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/UpdateConfiguration",
            warden__pb2.UpdateConfigRequest.SerializeToString,
            warden__pb2.UpdateConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def UpdateFrameStatus(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/UpdateFrameStatus",
            warden__pb2.UpdateFrameStatusRequest.SerializeToString,
            warden__pb2.UpdateFrameStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def HealthCheck(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/HealthCheck",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.HealthResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetStatus(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/warden.WardenService/GetStatus",
            warden__pb2.Empty.SerializeToString,
            warden__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )
