Commands and Operations

public interface JedisCommands extends KeyCommands, StringCommands, ListCommands, HashCommands,
    SetCommands, SortedSetCommands, GeoCommands, HyperLogLogCommands, StreamCommands,
    ScriptingKeyCommands, FunctionCommands {
    // Inherits all Redis commands from specialized interfaces
}

public interface JedisBinaryCommands extends KeyBinaryCommands, StringBinaryCommands,
    ListBinaryCommands, HashBinaryCommands, SetBinaryCommands, SortedSetBinaryCommands,
    GeoBinaryCommands, HyperLogLogBinaryCommands, StreamBinaryCommands, ScriptingKeyBinaryCommands,
    FunctionBinaryCommands {
    // Inherits all binary Redis commands
}

public interface StringCommands {
    /**
     * Set key to hold string value
     * @param key Redis key
     * @param value String value
     * @return Status code reply
     */
    String set(String key, String value);
    
    /**
     * Set key with additional parameters
     * @param key Redis key
     * @param value String value
     * @param params SET command parameters (EX, PX, NX, XX, etc.)
     * @return Status code reply or null if conditions not met
     */
    String set(String key, String value, SetParams params);
    
    /**
     * Get value of key
     * @param key Redis key
     * @return Value at key or null if key doesn't exist
     */
    String get(String key);
    
    /**
     * Get value of key and set new value atomically
     * @param key Redis key
     * @param value New value
     * @return Previous value at key
     */
    String getSet(String key, String value);
    
    /**
     * Get value and optionally set expiration
     * @param key Redis key
     * @param params GETEX parameters for expiration
     * @return Value at key
     */
    String getEx(String key, GetExParams params);
    
    /**
     * Get substring of value at key
     * @param key Redis key
     * @param startOffset Start position (inclusive)
     * @param endOffset End position (inclusive)
     * @return Substring of value
     */
    String getrange(String key, long startOffset, long endOffset);
    
    /**
     * Set value at key and return old value
     * @param key Redis key
     * @param value New value
     * @return Old value at key
     */
    String getDel(String key);
    
    /**
     * Set multiple keys to multiple values
     * @param keysvalues Alternating keys and values
     * @return Status code reply
     */
    String mset(String... keysvalues);
    
    /**
     * Set multiple keys only if none exist
     * @param keysvalues Alternating keys and values
     * @return 1 if all keys set, 0 if any key exists
     */
    Long msetnx(String... keysvalues);
    
    /**
     * Get values of multiple keys
     * @param keys Redis keys
     * @return List of values (null for non-existent keys)
     */
    List<String> mget(String... keys);
    
    /**
     * Increment value at key
     * @param key Redis key containing integer value
     * @return Value after increment
     */
    Long incr(String key);
    
    /**
     * Increment value at key by increment
     * @param key Redis key containing integer value
     * @param increment Amount to increment
     * @return Value after increment
     */
    Long incrBy(String key, long increment);
    
    /**
     * Increment float value at key
     * @param key Redis key containing float value
     * @param increment Float increment amount
     * @return Value after increment
     */
    Double incrByFloat(String key, double increment);
    
    /**
     * Decrement value at key
     * @param key Redis key containing integer value
     * @return Value after decrement
     */
    Long decr(String key);
    
    /**
     * Decrement value at key by decrement
     * @param key Redis key containing integer value
     * @param decrement Amount to decrement
     * @return Value after decrement
     */
    Long decrBy(String key, long decrement);
    
    /**
     * Append value to key
     * @param key Redis key
     * @param value Value to append
     * @return Length of string after append
     */
    Long append(String key, String value);
    
    /**
     * Get length of string at key
     * @param key Redis key
     * @return Length of string or 0 if key doesn't exist
     */
    Long strlen(String key);
}

jedis.set("counter", "0");
jedis.incr("counter");  // Returns 1
jedis.incrBy("counter", 5);  // Returns 6

jedis.set("user:1:name", "John");
jedis.append("user:1:name", " Doe");  // "John Doe"

// Multiple operations
jedis.mset("key1", "value1", "key2", "value2", "key3", "value3");
List<String> values = jedis.mget("key1", "key2", "key3");

// Conditional set
SetParams params = SetParams.setParams().nx().ex(3600);
String result = jedis.set("session:abc", "userdata", params);

public interface HashCommands {
    /**
     * Set field in hash to value
     * @param key Hash key
     * @param field Hash field
     * @param value Field value
     * @return 1 if new field, 0 if field updated
     */
    Long hset(String key, String field, String value);
    
    /**
     * Set multiple fields in hash
     * @param key Hash key
     * @param hash Map of field-value pairs
     * @return Number of fields added (not including updated fields)
     */
    Long hset(String key, Map<String, String> hash);
    
    /**
     * Get value of hash field
     * @param key Hash key
     * @param field Hash field
     * @return Field value or null if field doesn't exist
     */
    String hget(String key, String field);
    
    /**
     * Get all fields and values in hash
     * @param key Hash key
     * @return Map of all field-value pairs
     */
    Map<String, String> hgetAll(String key);
    
    /**
     * Get values of multiple hash fields
     * @param key Hash key
     * @param fields Hash fields
     * @return List of field values (null for non-existent fields)
     */
    List<String> hmget(String key, String... fields);
    
    /**
     * Set field only if it doesn't exist
     * @param key Hash key
     * @param field Hash field
     * @param value Field value
     * @return 1 if field set, 0 if field exists
     */
    Long hsetnx(String key, String field, String value);
    
    /**
     * Delete hash fields
     * @param key Hash key
     * @param fields Fields to delete
     * @return Number of fields deleted
     */
    Long hdel(String key, String... fields);
    
    /**
     * Check if hash field exists
     * @param key Hash key
     * @param field Hash field
     * @return true if field exists
     */
    Boolean hexists(String key, String field);
    
    /**
     * Get number of fields in hash
     * @param key Hash key
     * @return Number of fields
     */
    Long hlen(String key);
    
    /**
     * Get all field names in hash
     * @param key Hash key
     * @return Set of field names
     */
    Set<String> hkeys(String key);
    
    /**
     * Get all values in hash
     * @param key Hash key
     * @return List of field values
     */
    List<String> hvals(String key);
    
    /**
     * Increment hash field by increment
     * @param key Hash key
     * @param field Hash field
     * @param value Increment amount
     * @return Value after increment
     */
    Long hincrBy(String key, String field, long value);
    
    /**
     * Increment hash field by float increment
     * @param key Hash key
     * @param field Hash field
     * @param value Float increment amount
     * @return Value after increment
     */
    Double hincrByFloat(String key, String field, double value);
    
    /**
     * Scan hash fields and values
     * @param key Hash key
     * @param cursor Scan cursor
     * @return Scan result with cursor and field-value pairs
     */
    ScanResult<Map.Entry<String, String>> hscan(String key, String cursor);
    
    /**
     * Scan hash with parameters
     * @param key Hash key
     * @param cursor Scan cursor
     * @param params Scan parameters (MATCH, COUNT)
     * @return Scan result with cursor and field-value pairs
     */
    ScanResult<Map.Entry<String, String>> hscan(String key, String cursor, ScanParams params);
    
    /**
     * Get length of hash field value
     * @param key Hash key
     * @param field Hash field
     * @return Length of field value or 0 if field doesn't exist
     */
    Long hstrlen(String key, String field);
}

// User profile as hash
jedis.hset("user:1", "name", "John Doe");
jedis.hset("user:1", "email", "john@example.com");
jedis.hset("user:1", "age", "30");

// Get specific field
String name = jedis.hget("user:1", "name");

// Get all user data
Map<String, String> user = jedis.hgetAll("user:1");

// Increment age
jedis.hincrBy("user:1", "age", 1);

// Bulk operations
Map<String, String> profile = new HashMap<>();
profile.put("country", "USA");
profile.put("city", "New York");
jedis.hset("user:1", profile);

// Check if field exists
boolean hasPhone = jedis.hexists("user:1", "phone");

public interface ListCommands {
    /**
     * Push elements to head of list
     * @param key List key
     * @param strings Elements to push
     * @return Length of list after push
     */
    Long lpush(String key, String... strings);
    
    /**
     * Push elements to tail of list
     * @param key List key
     * @param strings Elements to push
     * @return Length of list after push
     */
    Long rpush(String key, String... strings);
    
    /**
     * Push element to head only if list exists
     * @param key List key
     * @param strings Elements to push
     * @return Length of list after push or 0 if list doesn't exist
     */
    Long lpushx(String key, String... strings);
    
    /**
     * Push element to tail only if list exists
     * @param key List key
     * @param strings Elements to push
     * @return Length of list after push or 0 if list doesn't exist
     */
    Long rpushx(String key, String... strings);
    
    /**
     * Pop element from head of list
     * @param key List key
     * @return Head element or null if list is empty
     */
    String lpop(String key);
    
    /**
     * Pop multiple elements from head of list
     * @param key List key
     * @param count Number of elements to pop
     * @return List of popped elements
     */
    List<String> lpop(String key, int count);
    
    /**
     * Pop element from tail of list
     * @param key List key
     * @return Tail element or null if list is empty
     */
    String rpop(String key);
    
    /**
     * Pop multiple elements from tail of list
     * @param key List key
     * @param count Number of elements to pop
     * @return List of popped elements
     */
    List<String> rpop(String key, int count);
    
    /**
     * Pop from tail of source list and push to head of destination
     * @param srckey Source list key
     * @param dstkey Destination list key
     * @return Element moved or null if source list is empty
     */
    String rpoplpush(String srckey, String dstkey);
    
    /**
     * Get list element at index
     * @param key List key
     * @param index Element index (0-based, negative for tail-relative)
     * @return Element at index or null if index out of range
     */
    String lindex(String key, long index);
    
    /**
     * Get list length
     * @param key List key
     * @return List length
     */
    Long llen(String key);
    
    /**
     * Get range of elements from list
     * @param key List key
     * @param start Start index (inclusive)
     * @param stop Stop index (inclusive, -1 for end)
     * @return List of elements in range
     */
    List<String> lrange(String key, long start, long stop);
    
    /**
     * Set list element at index
     * @param key List key
     * @param index Element index
     * @param value New element value
     * @return Status code reply
     */
    String lset(String key, long index, String value);
    
    /**
     * Trim list to specified range
     * @param key List key
     * @param start Start index (inclusive)
     * @param stop Stop index (inclusive)
     * @return Status code reply
     */
    String ltrim(String key, long start, long stop);
    
    /**
     * Remove elements from list
     * @param key List key
     * @param count Number to remove (0=all, >0=from head, <0=from tail)
     * @param element Element value to remove
     * @return Number of elements removed
     */
    Long lrem(String key, long count, String element);
    
    /**
     * Insert element before or after pivot
     * @param key List key
     * @param where INSERT position (BEFORE or AFTER)
     * @param pivot Pivot element
     * @param element Element to insert
     * @return List length after insert or -1 if pivot not found
     */
    Long linsert(String key, ListPosition where, String pivot, String element);
    
    /**
     * Find position of element in list
     * @param key List key
     * @param element Element to find
     * @return Index of first occurrence or null if not found
     */
    Long lpos(String key, String element);
    
    /**
     * Find positions of element in list with parameters
     * @param key List key
     * @param element Element to find
     * @param params LPOS parameters (RANK, COUNT, MAXLEN)
     * @return List of indices where element occurs
     */
    List<Long> lpos(String key, String element, LPosParams params);
    
    /**
     * Block until element available and pop from head
     * @param timeout Timeout in seconds (0 for infinite)
     * @param keys List keys to check
     * @return List with key name and popped element
     */
    List<String> blpop(int timeout, String... keys);
    
    /**
     * Block until element available and pop from tail
     * @param timeout Timeout in seconds (0 for infinite)
     * @param keys List keys to check
     * @return List with key name and popped element
     */
    List<String> brpop(int timeout, String... keys);
    
    /**
     * Block, pop from tail of source and push to head of destination
     * @param source Source list key
     * @param destination Destination list key
     * @param timeout Timeout in seconds
     * @return Element moved or null if timeout
     */
    String brpoplpush(String source, String destination, int timeout);
}

// Queue operations
jedis.lpush("queue", "task3", "task2", "task1");  // [task1, task2, task3]
String task = jedis.rpop("queue");  // "task3"

// Stack operations  
jedis.lpush("stack", "item1", "item2", "item3");
String item = jedis.lpop("stack");  // "item3"

// Range operations
List<String> items = jedis.lrange("queue", 0, -1);  // All items

// Blocking operations for producer/consumer
List<String> result = jedis.brpop(30, "work_queue");  // Wait up to 30 seconds

// List manipulation
jedis.linsert("mylist", ListPosition.BEFORE, "pivot", "new_element");
jedis.lrem("mylist", 1, "remove_me");  // Remove first occurrence

public interface SetCommands {
    /**
     * Add members to set
     * @param key Set key
     * @param members Members to add
     * @return Number of new members added
     */
    Long sadd(String key, String... members);
    
    /**
     * Get all members of set
     * @param key Set key
     * @return Set of all members
     */
    Set<String> smembers(String key);
    
    /**
     * Remove members from set
     * @param key Set key
     * @param members Members to remove
     * @return Number of members removed
     */
    Long srem(String key, String... members);
    
    /**
     * Remove and return random member from set
     * @param key Set key
     * @return Random member or null if set is empty
     */
    String spop(String key);
    
    /**
     * Remove and return multiple random members
     * @param key Set key
     * @param count Number of members to pop
     * @return Set of popped members
     */
    Set<String> spop(String key, long count);
    
    /**
     * Get random member without removing
     * @param key Set key
     * @return Random member or null if set is empty
     */
    String srandmember(String key);
    
    /**
     * Get multiple random members
     * @param key Set key
     * @param count Number of members (negative allows duplicates)
     * @return List of random members
     */
    List<String> srandmember(String key, int count);
    
    /**
     * Check if member exists in set
     * @param key Set key
     * @param member Member to check
     * @return true if member exists
     */
    Boolean sismember(String key, String member);
    
    /**
     * Check if multiple members exist in set
     * @param key Set key
     * @param members Members to check
     * @return List of boolean results for each member
     */
    List<Boolean> smismember(String key, String... members);
    
    /**
     * Get set cardinality (number of members)
     * @param key Set key
     * @return Number of members in set
     */
    Long scard(String key);
    
    /**
     * Move member from source to destination set
     * @param srckey Source set key
     * @param dstkey Destination set key
     * @param member Member to move
     * @return 1 if member moved, 0 if member doesn't exist in source
     */
    Long smove(String srckey, String dstkey, String member);
    
    /**
     * Intersect multiple sets
     * @param keys Set keys
     * @return Set intersection
     */
    Set<String> sinter(String... keys);
    
    /**
     * Store intersection of sets in destination key
     * @param dstkey Destination key
     * @param keys Source set keys
     * @return Number of members in resulting set
     */
    Long sinterstore(String dstkey, String... keys);
    
    /**
     * Union multiple sets
     * @param keys Set keys
     * @return Set union
     */
    Set<String> sunion(String... keys);
    
    /**
     * Store union of sets in destination key
     * @param dstkey Destination key
     * @param keys Source set keys
     * @return Number of members in resulting set
     */
    Long sunionstore(String dstkey, String... keys);
    
    /**
     * Difference of sets (first set minus others)
     * @param keys Set keys
     * @return Set difference
     */
    Set<String> sdiff(String... keys);
    
    /**
     * Store difference of sets in destination key
     * @param dstkey Destination key
     * @param keys Source set keys
     * @return Number of members in resulting set
     */
    Long sdiffstore(String dstkey, String... keys);
    
    /**
     * Scan set members
     * @param key Set key
     * @param cursor Scan cursor
     * @return Scan result with cursor and members
     */
    ScanResult<String> sscan(String key, String cursor);
    
    /**
     * Scan set with parameters
     * @param key Set key
     * @param cursor Scan cursor
     * @param params Scan parameters (MATCH, COUNT)
     * @return Scan result with cursor and members
     */
    ScanResult<String> sscan(String key, String cursor, ScanParams params);
}

// Tags system
jedis.sadd("user:1:tags", "java", "redis", "programming");
jedis.sadd("user:2:tags", "python", "redis", "data-science");

// Check membership
boolean hasTag = jedis.sismember("user:1:tags", "redis");  // true

// Set operations
Set<String> commonTags = jedis.sinter("user:1:tags", "user:2:tags");  // {"redis"}
Set<String> allTags = jedis.sunion("user:1:tags", "user:2:tags");

// Random operations
String randomTag = jedis.srandmember("user:1:tags");
Set<String> sample = jedis.spop("temp_set", 3);

public interface SortedSetCommands {
    /**
     * Add members with scores to sorted set
     * @param key Sorted set key
     * @param score Member score
     * @param member Member value
     * @return Number of new members added
     */
    Long zadd(String key, double score, String member);
    
    /**
     * Add multiple members with scores
     * @param key Sorted set key
     * @param scoreMembers Map of scores to members
     * @return Number of new members added
     */
    Long zadd(String key, Map<String, Double> scoreMembers);
    
    /**
     * Add members with parameters
     * @param key Sorted set key
     * @param scoreMembers Score-member pairs
     * @param params ZADD parameters (NX, XX, CH, INCR)
     * @return Number affected or updated score if INCR used
     */
    Long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params);
    
    /**
     * Get range of members by index
     * @param key Sorted set key
     * @param start Start index (0-based)
     * @param stop Stop index (-1 for end)
     * @return List of members in range
     */
    List<String> zrange(String key, long start, long stop);
    
    /**
     * Get range with scores
     * @param key Sorted set key
     * @param start Start index
     * @param stop Stop index
     * @return List of members with scores
     */
    List<Tuple> zrangeWithScores(String key, long start, long stop);
    
    /**
     * Get reverse range by index
     * @param key Sorted set key
     * @param start Start index
     * @param stop Stop index
     * @return List of members in reverse order
     */
    List<String> zrevrange(String key, long start, long stop);
    
    /**
     * Get reverse range with scores
     * @param key Sorted set key
     * @param start Start index
     * @param stop Stop index
     * @return List of members with scores in reverse order
     */
    List<Tuple> zrevrangeWithScores(String key, long start, long stop);
    
    /**
     * Get range by score
     * @param key Sorted set key
     * @param min Minimum score (inclusive)
     * @param max Maximum score (inclusive)
     * @return List of members in score range
     */
    List<String> zrangeByScore(String key, double min, double max);
    
    /**
     * Get range by score with limit
     * @param key Sorted set key
     * @param min Minimum score
     * @param max Maximum score
     * @param offset Result offset
     * @param count Result count limit
     * @return List of members in score range
     */
    List<String> zrangeByScore(String key, double min, double max, int offset, int count);
    
    /**
     * Get range by score with scores
     * @param key Sorted set key
     * @param min Minimum score
     * @param max Maximum score
     * @return List of members with scores
     */
    List<Tuple> zrangeByScoreWithScores(String key, double min, double max);
    
    /**
     * Get member rank (0-based index)
     * @param key Sorted set key
     * @param member Member value
     * @return Rank of member or null if not found
     */
    Long zrank(String key, String member);
    
    /**
     * Get member reverse rank
     * @param key Sorted set key
     * @param member Member value
     * @return Reverse rank of member or null if not found
     */
    Long zrevrank(String key, String member);
    
    /**
     * Get member score
     * @param key Sorted set key
     * @param member Member value
     * @return Score of member or null if not found
     */
    Double zscore(String key, String member);
    
    /**
     * Get multiple member scores
     * @param key Sorted set key
     * @param members Member values
     * @return List of scores (null for non-existent members)
     */
    List<Double> zmscore(String key, String... members);
    
    /**
     * Remove members from sorted set
     * @param key Sorted set key
     * @param members Members to remove
     * @return Number of members removed
     */
    Long zrem(String key, String... members);
    
    /**
     * Remove members by rank range
     * @param key Sorted set key
     * @param start Start rank (inclusive)
     * @param stop Stop rank (inclusive)
     * @return Number of members removed
     */
    Long zremrangeByRank(String key, long start, long stop);
    
    /**
     * Remove members by score range
     * @param key Sorted set key
     * @param min Minimum score (inclusive)
     * @param max Maximum score (inclusive)
     * @return Number of members removed
     */
    Long zremrangeByScore(String key, double min, double max);
    
    /**
     * Get cardinality of sorted set
     * @param key Sorted set key
     * @return Number of members
     */
    Long zcard(String key);
    
    /**
     * Count members in score range
     * @param key Sorted set key
     * @param min Minimum score
     * @param max Maximum score
     * @return Number of members in range
     */
    Long zcount(String key, double min, double max);
    
    /**
     * Increment member score
     * @param key Sorted set key
     * @param increment Score increment
     * @param member Member value
     * @return New score of member
     */
    Double zincrby(String key, double increment, String member);
    
    /**
     * Union multiple sorted sets and store result
     * @param dstkey Destination key
     * @param sets Source sorted set keys
     * @return Number of members in resulting set
     */
    Long zunionstore(String dstkey, String... sets);
    
    /**
     * Union with parameters
     * @param dstkey Destination key
     * @param params Union parameters (weights, aggregate function)
     * @param sets Source sorted set keys
     * @return Number of members in resulting set
     */
    Long zunionstore(String dstkey, ZParams params, String... sets);
    
    /**
     * Intersect multiple sorted sets and store result
     * @param dstkey Destination key
     * @param sets Source sorted set keys
     * @return Number of members in resulting set
     */
    Long zinterstore(String dstkey, String... sets);
    
    /**
     * Intersect with parameters
     * @param dstkey Destination key
     * @param params Intersection parameters
     * @param sets Source sorted set keys
     * @return Number of members in resulting set
     */
    Long zinterstore(String dstkey, ZParams params, String... sets);
    
    /**
     * Scan sorted set members
     * @param key Sorted set key
     * @param cursor Scan cursor
     * @return Scan result with cursor and members with scores
     */
    ScanResult<Tuple> zscan(String key, String cursor);
}

// Leaderboard
jedis.zadd("leaderboard", 1000, "player1");
jedis.zadd("leaderboard", 1500, "player2");
jedis.zadd("leaderboard", 800, "player3");

// Get top players
List<String> topPlayers = jedis.zrevrange("leaderboard", 0, 2);

// Get player rank
Long rank = jedis.zrevrank("leaderboard", "player1");  // 1 (0-based)

// Get score
Double score = jedis.zscore("leaderboard", "player1");  // 1000.0

// Range by score
List<String> midRange = jedis.zrangeByScore("leaderboard", 900, 1200);

// Increment score
jedis.zincrby("leaderboard", 100, "player1");  // New score: 1100

// Time-based scoring (timestamps)
long timestamp = System.currentTimeMillis();
jedis.zadd("recent_activity", timestamp, "user:123");

public interface KeyCommands {
    /**
     * Check if key exists
     * @param key Redis key
     * @return true if key exists
     */
    Boolean exists(String key);
    
    /**
     * Check if multiple keys exist
     * @param keys Redis keys
     * @return Number of existing keys
     */
    Long exists(String... keys);
    
    /**
     * Delete keys
     * @param keys Keys to delete
     * @return Number of keys deleted
     */
    Long del(String... keys);
    
    /**
     * Unlink keys (non-blocking delete)
     * @param keys Keys to unlink
     * @return Number of keys unlinked
     */
    Long unlink(String... keys);
    
    /**
     * Get key type
     * @param key Redis key
     * @return Key type (string, list, set, zset, hash, stream)
     */
    String type(String key);
    
    /**
     * Set key expiration in seconds
     * @param key Redis key
     * @param seconds Expiration time in seconds
     * @return 1 if timeout set, 0 if key doesn't exist
     */
    Long expire(String key, long seconds);
    
    /**
     * Set key expiration at Unix timestamp
     * @param key Redis key
     * @param unixTime Unix timestamp in seconds
     * @return 1 if timeout set, 0 if key doesn't exist
     */
    Long expireAt(String key, long unixTime);
    
    /**
     * Set key expiration in milliseconds
     * @param key Redis key
     * @param milliseconds Expiration time in milliseconds
     * @return 1 if timeout set, 0 if key doesn't exist
     */
    Long pexpire(String key, long milliseconds);
    
    /**
     * Set key expiration at Unix timestamp in milliseconds
     * @param key Redis key
     * @param millisecondsTimestamp Unix timestamp in milliseconds
     * @return 1 if timeout set, 0 if key doesn't exist
     */
    Long pexpireAt(String key, long millisecondsTimestamp);
    
    /**
     * Get time to live in seconds
     * @param key Redis key
     * @return TTL in seconds, -1 if no expiry, -2 if key doesn't exist
     */
    Long ttl(String key);
    
    /**
     * Get time to live in milliseconds
     * @param key Redis key
     * @return TTL in milliseconds, -1 if no expiry, -2 if key doesn't exist
     */
    Long pttl(String key);
    
    /**
     * Remove expiration from key
     * @param key Redis key
     * @return 1 if expiration removed, 0 if key has no expiry or doesn't exist
     */
    Long persist(String key);
    
    /**
     * Rename key
     * @param oldkey Current key name
     * @param newkey New key name
     * @return Status code reply
     */
    String rename(String oldkey, String newkey);
    
    /**
     * Rename key only if new key doesn't exist
     * @param oldkey Current key name
     * @param newkey New key name
     * @return 1 if key renamed, 0 if new key exists
     */
    Long renamenx(String oldkey, String newkey);
    
    /**
     * Get random key from keyspace
     * @return Random key or null if database is empty
     */
    String randomKey();
    
    /**
     * Move key to different database
     * @param key Redis key
     * @param dbIndex Target database index
     * @return 1 if key moved, 0 if key doesn't exist or target exists
     */
    Long move(String key, int dbIndex);
    
    /**
     * Find keys matching pattern
     * @param pattern Key pattern (glob-style)
     * @return Set of matching keys
     */
    Set<String> keys(String pattern);
    
    /**
     * Scan keyspace
     * @param cursor Scan cursor
     * @return Scan result with cursor and keys
     */
    ScanResult<String> scan(String cursor);
    
    /**
     * Scan keyspace with parameters
     * @param cursor Scan cursor
     * @param params Scan parameters (MATCH, COUNT, TYPE)
     * @return Scan result with cursor and keys
     */
    ScanResult<String> scan(String cursor, ScanParams params);
    
    /**
     * Sort list, set, or sorted set
     * @param key Key to sort
     * @return Sorted list of elements
     */
    List<String> sort(String key);
    
    /**
     * Sort with parameters
     * @param key Key to sort
     * @param sortingParams Sorting parameters (BY, LIMIT, GET, etc.)
     * @return Sorted list of elements
     */
    List<String> sort(String key, SortingParams sortingParams);
    
    /**
     * Sort and store result
     * @param key Key to sort
     * @param dstkey Destination key for sorted result
     * @return Number of elements in sorted result
     */
    Long sort(String key, String dstkey);
    
    /**
     * Get object encoding of key
     * @param key Redis key
     * @return Encoding type
     */
    String objectEncoding(String key);
    
    /**
     * Get object idle time
     * @param key Redis key
     * @return Idle time in seconds
     */
    Long objectIdletime(String key);
    
    /**
     * Get object reference count
     * @param key Redis key
     * @return Reference count
     */
    Long objectRefcount(String key);
}

// Key lifecycle management
jedis.set("session:abc", "userdata");
jedis.expire("session:abc", 3600);  // Expire in 1 hour

Long ttl = jedis.ttl("session:abc");  // Time to live

// Key discovery (use SCAN in production instead of KEYS)
ScanResult<String> result = jedis.scan("0", new ScanParams().match("user:*").count(100));

// Key information
String type = jedis.type("mykey");
String encoding = jedis.objectEncoding("mykey");
Long idleTime = jedis.objectIdletime("mykey");

// Atomic rename
jedis.rename("old_key", "new_key");

public interface GeoCommands {
    /**
     * Add geospatial members with coordinates
     * @param key Geo set key
     * @param longitude Longitude coordinate
     * @param latitude Latitude coordinate
     * @param member Member name
     * @return Number of new members added
     */
    Long geoadd(String key, double longitude, double latitude, String member);
    
    /**
     * Add multiple geospatial members
     * @param key Geo set key
     * @param memberCoordinateMap Map of members to coordinates
     * @return Number of new members added
     */
    Long geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap);
    
    /**
     * Add geospatial members with parameters
     * @param key Geo set key
     * @param params GEOADD parameters (NX, XX)
     * @param memberCoordinateMap Map of members to coordinates
     * @return Number affected (added or updated)
     */
    Long geoadd(String key, GeoAddParams params, Map<String, GeoCoordinate> memberCoordinateMap);
    
    /**
     * Get distance between two members
     * @param key Geo set key
     * @param member1 First member
     * @param member2 Second member
     * @return Distance in meters
     */
    Double geodist(String key, String member1, String member2);
    
    /**
     * Get distance with unit
     * @param key Geo set key
     * @param member1 First member
     * @param member2 Second member
     * @param unit Distance unit (M, KM, MI, FT)
     * @return Distance in specified unit
     */
    Double geodist(String key, String member1, String member2, GeoUnit unit);
    
    /**
     * Get geohash strings for members
     * @param key Geo set key
     * @param members Member names
     * @return List of geohash strings
     */
    List<String> geohash(String key, String... members);
    
    /**
     * Get coordinates for members
     * @param key Geo set key
     * @param members Member names
     * @return List of coordinates (null for non-existent members)
     */
    List<GeoCoordinate> geopos(String key, String... members);
    
    /**
     * Find members within radius of coordinates
     * @param key Geo set key
     * @param longitude Center longitude
     * @param latitude Center latitude
     * @param radius Search radius
     * @param unit Radius unit
     * @return List of members within radius
     */
    List<GeoRadiusResponse> georadius(String key, double longitude, double latitude, 
                                     double radius, GeoUnit unit);
    
    /**
     * Find members within radius with parameters
     * @param key Geo set key
     * @param longitude Center longitude
     * @param latitude Center latitude
     * @param radius Search radius
     * @param unit Radius unit
     * @param param Query parameters (WITHCOORD, WITHDIST, COUNT, etc.)
     * @return List of members with requested information
     */
    List<GeoRadiusResponse> georadius(String key, double longitude, double latitude,
                                     double radius, GeoUnit unit, GeoRadiusParam param);
    
    /**
     * Find members within radius of existing member
     * @param key Geo set key
     * @param member Center member
     * @param radius Search radius
     * @param unit Radius unit
     * @return List of members within radius
     */
    List<GeoRadiusResponse> georadiusByMember(String key, String member, 
                                             double radius, GeoUnit unit);
    
    /**
     * Find members within radius of member with parameters
     * @param key Geo set key
     * @param member Center member
     * @param radius Search radius
     * @param unit Radius unit
     * @param param Query parameters
     * @return List of members with requested information
     */
    List<GeoRadiusResponse> georadiusByMember(String key, String member,
                                             double radius, GeoUnit unit, 
                                             GeoRadiusParam param);
    
    /**
     * Search members by distance or box
     * @param key Geo set key
     * @param params Search parameters (BY RADIUS/BOX, FROM MEMBER/LONLAT, etc.)
     * @return List of matching members
     */
    List<GeoRadiusResponse> geosearch(String key, GeoSearchParam params);
    
    /**
     * Search and store results in destination key
     * @param dest Destination key
     * @param src Source geo set key
     * @param params Search parameters
     * @return Number of members stored
     */
    Long geosearchStore(String dest, String src, GeoSearchParam params);
}

// Add locations
jedis.geoadd("cities", -74.0059, 40.7128, "New York");
jedis.geoadd("cities", -118.2437, 34.0522, "Los Angeles");
jedis.geoadd("cities", -87.6298, 41.8781, "Chicago");

// Get distance between cities
Double distance = jedis.geodist("cities", "New York", "Chicago", GeoUnit.MI);

// Find cities within radius
List<GeoRadiusResponse> nearby = jedis.georadius("cities", -74.0, 40.7, 
    500, GeoUnit.MI, 
    GeoRadiusParam.geoRadiusParam().withDist().withCoord().sortAscending()
);

for (GeoRadiusResponse city : nearby) {
    System.out.println(city.getMemberByString() + " - " + 
                      city.getDistance() + " miles");
}

// Get coordinates
List<GeoCoordinate> coords = jedis.geopos("cities", "New York", "Chicago");