Module spin_sdk.wit.imports.redis

class Connection:
    
    @classmethod
    def open(cls, address: str) -> Self:
        """
        Open a connection to the Redis instance at `address`.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def publish(self, channel: str, payload: bytes) -> None:
        """
        Publish a Redis message to the specified channel.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def get(self, key: str) -> Optional[bytes]:
        """
        Get the value of a key.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def set(self, key: str, value: bytes) -> None:
        """
        Set key to value.
        
        If key already holds a value, it is overwritten.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def incr(self, key: str) -> int:
        """
        Increments the number stored at key by one.
        
        If the key does not exist, it is set to 0 before performing the operation.
        An `error::type-error` is returned if the key contains a value of the wrong type
        or contains a string that can not be represented as integer.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def del_(self, keys: List[str]) -> int:
        """
        Removes the specified keys.
        
        A key is ignored if it does not exist. Returns the number of keys deleted.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def sadd(self, key: str, values: List[str]) -> int:
        """
        Add the specified `values` to the set named `key`, returning the number of newly-added values.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def smembers(self, key: str) -> List[str]:
        """
        Retrieve the contents of the set named `key`.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def srem(self, key: str, values: List[str]) -> int:
        """
        Remove the specified `values` from the set named `key`, returning the number of newly-removed values.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def execute(self, command: str, arguments: List[RedisParameter]) -> List[RedisResult]:
        """
        Execute an arbitrary Redis command and receive the result.
        
        Raises: `spin_sdk.wit.types.Err(spin_sdk.wit.imports.redis.Error)`
        """
        raise NotImplementedError
    def __enter__(self) -> Self:
        """Returns self"""
        return self
                                
    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> bool | None:
        """
        Release this resource.
        """
        raise NotImplementedError

@dataclass
class Error_InvalidAddress:
    pass

@dataclass
class Error_Other:
    value: str

@dataclass
class Error_TooManyConnections:
    pass

@dataclass
class Error_TypeError:
    pass

@dataclass
class RedisParameter_Binary:
    value: bytes

@dataclass
class RedisParameter_Int64:
    value: int

@dataclass
class RedisResult_Binary:
    value: bytes

@dataclass
class RedisResult_Int64:
    value: int

@dataclass
class RedisResult_Nil:
    pass

@dataclass
class RedisResult_Status:
    value: str