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

from . import postgres_service_pb2 as postgres__service__pb2

GRPC_GENERATED_VERSION = '1.75.1'
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},'
        + f' but the generated code in postgres_service_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 PostgresServiceStub(object):
    """========================================
    PostgreSQL Database Service
    ========================================
    Provides centralized PostgreSQL access with:
    - Connection pooling (Go concurrent processing)
    - Transaction support
    - Batch operations
    - Direct SQL execution
    - JSONB support
    - Full-text search

    Note: Vector operations are handled by Qdrant service

    ========== Basic CRUD Operations ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Query = channel.unary_unary(
                '/isa.postgres.PostgresService/Query',
                request_serializer=postgres__service__pb2.QueryRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.QueryResponse.FromString,
                _registered_method=True)
        self.QueryRow = channel.unary_unary(
                '/isa.postgres.PostgresService/QueryRow',
                request_serializer=postgres__service__pb2.QueryRowRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.QueryRowResponse.FromString,
                _registered_method=True)
        self.Execute = channel.unary_unary(
                '/isa.postgres.PostgresService/Execute',
                request_serializer=postgres__service__pb2.ExecuteRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.ExecuteResponse.FromString,
                _registered_method=True)
        self.ExecuteBatch = channel.unary_unary(
                '/isa.postgres.PostgresService/ExecuteBatch',
                request_serializer=postgres__service__pb2.ExecuteBatchRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.ExecuteBatchResponse.FromString,
                _registered_method=True)
        self.SelectFrom = channel.unary_unary(
                '/isa.postgres.PostgresService/SelectFrom',
                request_serializer=postgres__service__pb2.SelectFromRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.SelectFromResponse.FromString,
                _registered_method=True)
        self.InsertInto = channel.unary_unary(
                '/isa.postgres.PostgresService/InsertInto',
                request_serializer=postgres__service__pb2.InsertIntoRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.InsertIntoResponse.FromString,
                _registered_method=True)
        self.UpdateTable = channel.unary_unary(
                '/isa.postgres.PostgresService/UpdateTable',
                request_serializer=postgres__service__pb2.UpdateTableRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.UpdateTableResponse.FromString,
                _registered_method=True)
        self.DeleteFrom = channel.unary_unary(
                '/isa.postgres.PostgresService/DeleteFrom',
                request_serializer=postgres__service__pb2.DeleteFromRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.DeleteFromResponse.FromString,
                _registered_method=True)
        self.BeginTransaction = channel.unary_unary(
                '/isa.postgres.PostgresService/BeginTransaction',
                request_serializer=postgres__service__pb2.BeginTransactionRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.BeginTransactionResponse.FromString,
                _registered_method=True)
        self.CommitTransaction = channel.unary_unary(
                '/isa.postgres.PostgresService/CommitTransaction',
                request_serializer=postgres__service__pb2.CommitTransactionRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.CommitTransactionResponse.FromString,
                _registered_method=True)
        self.RollbackTransaction = channel.unary_unary(
                '/isa.postgres.PostgresService/RollbackTransaction',
                request_serializer=postgres__service__pb2.RollbackTransactionRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.RollbackTransactionResponse.FromString,
                _registered_method=True)
        self.ExecuteInTransaction = channel.unary_unary(
                '/isa.postgres.PostgresService/ExecuteInTransaction',
                request_serializer=postgres__service__pb2.ExecuteInTransactionRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.ExecuteInTransactionResponse.FromString,
                _registered_method=True)
        self.GetTableInfo = channel.unary_unary(
                '/isa.postgres.PostgresService/GetTableInfo',
                request_serializer=postgres__service__pb2.GetTableInfoRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.GetTableInfoResponse.FromString,
                _registered_method=True)
        self.ListTables = channel.unary_unary(
                '/isa.postgres.PostgresService/ListTables',
                request_serializer=postgres__service__pb2.ListTablesRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.ListTablesResponse.FromString,
                _registered_method=True)
        self.TableExists = channel.unary_unary(
                '/isa.postgres.PostgresService/TableExists',
                request_serializer=postgres__service__pb2.TableExistsRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.TableExistsResponse.FromString,
                _registered_method=True)
        self.HealthCheck = channel.unary_unary(
                '/isa.postgres.PostgresService/HealthCheck',
                request_serializer=postgres__service__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.HealthCheckResponse.FromString,
                _registered_method=True)
        self.GetStats = channel.unary_unary(
                '/isa.postgres.PostgresService/GetStats',
                request_serializer=postgres__service__pb2.GetStatsRequest.SerializeToString,
                response_deserializer=postgres__service__pb2.GetStatsResponse.FromString,
                _registered_method=True)


class PostgresServiceServicer(object):
    """========================================
    PostgreSQL Database Service
    ========================================
    Provides centralized PostgreSQL access with:
    - Connection pooling (Go concurrent processing)
    - Transaction support
    - Batch operations
    - Direct SQL execution
    - JSONB support
    - Full-text search

    Note: Vector operations are handled by Qdrant service

    ========== Basic CRUD Operations ==========
    """

    def Query(self, request, context):
        """Query - Execute SELECT query
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def QueryRow(self, request, context):
        """QueryRow - Execute SELECT and return single row
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Execute(self, request, context):
        """Execute - Execute INSERT/UPDATE/DELETE
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExecuteBatch(self, request, context):
        """ExecuteBatch - Execute multiple operations in batch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SelectFrom(self, request, context):
        """========== Table Operations (Builder API) ==========

        SelectFrom - Query builder style SELECT
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InsertInto(self, request, context):
        """InsertInto - Insert rows into table
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateTable(self, request, context):
        """UpdateTable - Update rows in table
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteFrom(self, request, context):
        """DeleteFrom - Delete rows from table
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def BeginTransaction(self, request, context):
        """========== Transaction Support ==========

        BeginTransaction - Start a new transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CommitTransaction(self, request, context):
        """CommitTransaction - Commit transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RollbackTransaction(self, request, context):
        """RollbackTransaction - Rollback transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExecuteInTransaction(self, request, context):
        """ExecuteInTransaction - Execute operations within a transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetTableInfo(self, request, context):
        """========== Schema & Metadata ==========

        GetTableInfo - Get table schema information
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListTables(self, request, context):
        """ListTables - List all tables in schema
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TableExists(self, request, context):
        """TableExists - Check if table exists
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HealthCheck(self, request, context):
        """========== Health & Stats ==========

        HealthCheck - Service health check
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetStats(self, request, context):
        """GetStats - Get connection pool and database statistics
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_PostgresServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Query': grpc.unary_unary_rpc_method_handler(
                    servicer.Query,
                    request_deserializer=postgres__service__pb2.QueryRequest.FromString,
                    response_serializer=postgres__service__pb2.QueryResponse.SerializeToString,
            ),
            'QueryRow': grpc.unary_unary_rpc_method_handler(
                    servicer.QueryRow,
                    request_deserializer=postgres__service__pb2.QueryRowRequest.FromString,
                    response_serializer=postgres__service__pb2.QueryRowResponse.SerializeToString,
            ),
            'Execute': grpc.unary_unary_rpc_method_handler(
                    servicer.Execute,
                    request_deserializer=postgres__service__pb2.ExecuteRequest.FromString,
                    response_serializer=postgres__service__pb2.ExecuteResponse.SerializeToString,
            ),
            'ExecuteBatch': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteBatch,
                    request_deserializer=postgres__service__pb2.ExecuteBatchRequest.FromString,
                    response_serializer=postgres__service__pb2.ExecuteBatchResponse.SerializeToString,
            ),
            'SelectFrom': grpc.unary_unary_rpc_method_handler(
                    servicer.SelectFrom,
                    request_deserializer=postgres__service__pb2.SelectFromRequest.FromString,
                    response_serializer=postgres__service__pb2.SelectFromResponse.SerializeToString,
            ),
            'InsertInto': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertInto,
                    request_deserializer=postgres__service__pb2.InsertIntoRequest.FromString,
                    response_serializer=postgres__service__pb2.InsertIntoResponse.SerializeToString,
            ),
            'UpdateTable': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateTable,
                    request_deserializer=postgres__service__pb2.UpdateTableRequest.FromString,
                    response_serializer=postgres__service__pb2.UpdateTableResponse.SerializeToString,
            ),
            'DeleteFrom': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteFrom,
                    request_deserializer=postgres__service__pb2.DeleteFromRequest.FromString,
                    response_serializer=postgres__service__pb2.DeleteFromResponse.SerializeToString,
            ),
            'BeginTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.BeginTransaction,
                    request_deserializer=postgres__service__pb2.BeginTransactionRequest.FromString,
                    response_serializer=postgres__service__pb2.BeginTransactionResponse.SerializeToString,
            ),
            'CommitTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.CommitTransaction,
                    request_deserializer=postgres__service__pb2.CommitTransactionRequest.FromString,
                    response_serializer=postgres__service__pb2.CommitTransactionResponse.SerializeToString,
            ),
            'RollbackTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.RollbackTransaction,
                    request_deserializer=postgres__service__pb2.RollbackTransactionRequest.FromString,
                    response_serializer=postgres__service__pb2.RollbackTransactionResponse.SerializeToString,
            ),
            'ExecuteInTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteInTransaction,
                    request_deserializer=postgres__service__pb2.ExecuteInTransactionRequest.FromString,
                    response_serializer=postgres__service__pb2.ExecuteInTransactionResponse.SerializeToString,
            ),
            'GetTableInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTableInfo,
                    request_deserializer=postgres__service__pb2.GetTableInfoRequest.FromString,
                    response_serializer=postgres__service__pb2.GetTableInfoResponse.SerializeToString,
            ),
            'ListTables': grpc.unary_unary_rpc_method_handler(
                    servicer.ListTables,
                    request_deserializer=postgres__service__pb2.ListTablesRequest.FromString,
                    response_serializer=postgres__service__pb2.ListTablesResponse.SerializeToString,
            ),
            'TableExists': grpc.unary_unary_rpc_method_handler(
                    servicer.TableExists,
                    request_deserializer=postgres__service__pb2.TableExistsRequest.FromString,
                    response_serializer=postgres__service__pb2.TableExistsResponse.SerializeToString,
            ),
            'HealthCheck': grpc.unary_unary_rpc_method_handler(
                    servicer.HealthCheck,
                    request_deserializer=postgres__service__pb2.HealthCheckRequest.FromString,
                    response_serializer=postgres__service__pb2.HealthCheckResponse.SerializeToString,
            ),
            'GetStats': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStats,
                    request_deserializer=postgres__service__pb2.GetStatsRequest.FromString,
                    response_serializer=postgres__service__pb2.GetStatsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'isa.postgres.PostgresService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('isa.postgres.PostgresService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class PostgresService(object):
    """========================================
    PostgreSQL Database Service
    ========================================
    Provides centralized PostgreSQL access with:
    - Connection pooling (Go concurrent processing)
    - Transaction support
    - Batch operations
    - Direct SQL execution
    - JSONB support
    - Full-text search

    Note: Vector operations are handled by Qdrant service

    ========== Basic CRUD Operations ==========
    """

    @staticmethod
    def Query(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,
            '/isa.postgres.PostgresService/Query',
            postgres__service__pb2.QueryRequest.SerializeToString,
            postgres__service__pb2.QueryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def QueryRow(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,
            '/isa.postgres.PostgresService/QueryRow',
            postgres__service__pb2.QueryRowRequest.SerializeToString,
            postgres__service__pb2.QueryRowResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Execute(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,
            '/isa.postgres.PostgresService/Execute',
            postgres__service__pb2.ExecuteRequest.SerializeToString,
            postgres__service__pb2.ExecuteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExecuteBatch(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,
            '/isa.postgres.PostgresService/ExecuteBatch',
            postgres__service__pb2.ExecuteBatchRequest.SerializeToString,
            postgres__service__pb2.ExecuteBatchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SelectFrom(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,
            '/isa.postgres.PostgresService/SelectFrom',
            postgres__service__pb2.SelectFromRequest.SerializeToString,
            postgres__service__pb2.SelectFromResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InsertInto(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,
            '/isa.postgres.PostgresService/InsertInto',
            postgres__service__pb2.InsertIntoRequest.SerializeToString,
            postgres__service__pb2.InsertIntoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateTable(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,
            '/isa.postgres.PostgresService/UpdateTable',
            postgres__service__pb2.UpdateTableRequest.SerializeToString,
            postgres__service__pb2.UpdateTableResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteFrom(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,
            '/isa.postgres.PostgresService/DeleteFrom',
            postgres__service__pb2.DeleteFromRequest.SerializeToString,
            postgres__service__pb2.DeleteFromResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def BeginTransaction(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,
            '/isa.postgres.PostgresService/BeginTransaction',
            postgres__service__pb2.BeginTransactionRequest.SerializeToString,
            postgres__service__pb2.BeginTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CommitTransaction(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,
            '/isa.postgres.PostgresService/CommitTransaction',
            postgres__service__pb2.CommitTransactionRequest.SerializeToString,
            postgres__service__pb2.CommitTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RollbackTransaction(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,
            '/isa.postgres.PostgresService/RollbackTransaction',
            postgres__service__pb2.RollbackTransactionRequest.SerializeToString,
            postgres__service__pb2.RollbackTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExecuteInTransaction(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,
            '/isa.postgres.PostgresService/ExecuteInTransaction',
            postgres__service__pb2.ExecuteInTransactionRequest.SerializeToString,
            postgres__service__pb2.ExecuteInTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTableInfo(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,
            '/isa.postgres.PostgresService/GetTableInfo',
            postgres__service__pb2.GetTableInfoRequest.SerializeToString,
            postgres__service__pb2.GetTableInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListTables(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,
            '/isa.postgres.PostgresService/ListTables',
            postgres__service__pb2.ListTablesRequest.SerializeToString,
            postgres__service__pb2.ListTablesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TableExists(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,
            '/isa.postgres.PostgresService/TableExists',
            postgres__service__pb2.TableExistsRequest.SerializeToString,
            postgres__service__pb2.TableExistsResponse.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,
            '/isa.postgres.PostgresService/HealthCheck',
            postgres__service__pb2.HealthCheckRequest.SerializeToString,
            postgres__service__pb2.HealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStats(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,
            '/isa.postgres.PostgresService/GetStats',
            postgres__service__pb2.GetStatsRequest.SerializeToString,
            postgres__service__pb2.GetStatsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
