bun-types-no-globals 1.2.23-canary.20250925T140721 → 1.2.23-canary.20250927T140547

package/lib/bun.d.ts

@@ -5047,6 +5047,7 @@ declare module "bun" {
   type SupportedCryptoAlgorithms =
     | "blake2b256"
     | "blake2b512"
+    | "blake2s256"
     | "md4"
     | "md5"
     | "ripemd160"

package/lib/redis.d.ts

@@ -52,21 +52,25 @@ declare module "bun" {
 
   export namespace RedisClient {
     type KeyLike = string | ArrayBufferView | Blob;
+    type StringPubSubListener = (message: string, channel: string) => void;
+
+    // Buffer subscriptions are not yet implemented
+    // type BufferPubSubListener = (message: Uint8Array<ArrayBuffer>, channel: string) => void;
   }
 
   export class RedisClient {
     /**
      * Creates a new Redis client
-     * @param url URL to connect to, defaults to process.env.VALKEY_URL, process.env.REDIS_URL, or "valkey://localhost:6379"
+     *
+     * @param url URL to connect to, defaults to `process.env.VALKEY_URL`,
+     * `process.env.REDIS_URL`, or `"valkey://localhost:6379"`
      * @param options Additional options
      *
      * @example
      * ```ts
-     * const valkey = new RedisClient();
-     *
-     * await valkey.set("hello", "world");
-     *
-     * console.log(await valkey.get("hello"));
+     * const redis = new RedisClient();
+     * await redis.set("hello", "world");
+     * console.log(await redis.get("hello"));
      * ```
      */
     constructor(url?: string, options?: RedisOptions);
@@ -88,12 +92,14 @@ declare module "bun" {
 
     /**
      * Callback fired when the client disconnects from the Redis server
+     *
      * @param error The error that caused the disconnection
      */
     onclose: ((this: RedisClient, error: Error) => void) | null;
 
     /**
      * Connect to the Redis server
+     *
      * @returns A promise that resolves when connected
      */
     connect(): Promise<void>;
@@ -152,10 +158,12 @@ declare module "bun" {
     set(key: RedisClient.KeyLike, value: RedisClient.KeyLike, px: "PX", milliseconds: number): Promise<"OK">;
 
     /**
-     * Set key to hold the string value with expiration at a specific Unix timestamp
+     * Set key to hold the string value with expiration at a specific Unix
+     * timestamp
      * @param key The key to set
      * @param value The value to set
-     * @param exat Set the specified Unix time at which the key will expire, in seconds
+     * @param exat Set the specified Unix time at which the key will expire, in
+     * seconds
      * @returns Promise that resolves with "OK" on success
      */
     set(key: RedisClient.KeyLike, value: RedisClient.KeyLike, exat: "EXAT", timestampSeconds: number): Promise<"OK">;
@@ -179,7 +187,8 @@ declare module "bun" {
      * @param key The key to set
      * @param value The value to set
      * @param nx Only set the key if it does not already exist
-     * @returns Promise that resolves with "OK" on success, or null if the key already exists
+     * @returns Promise that resolves with "OK" on success, or null if the key
+     * already exists
      */
     set(key: RedisClient.KeyLike, value: RedisClient.KeyLike, nx: "NX"): Promise<"OK" | null>;
 
@@ -188,7 +197,8 @@ declare module "bun" {
      * @param key The key to set
      * @param value The value to set
      * @param xx Only set the key if it already exists
-     * @returns Promise that resolves with "OK" on success, or null if the key does not exist
+     * @returns Promise that resolves with "OK" on success, or null if the key
+     * does not exist
      */
     set(key: RedisClient.KeyLike, value: RedisClient.KeyLike, xx: "XX"): Promise<"OK" | null>;
 
@@ -196,8 +206,10 @@ declare module "bun" {
      * Set key to hold the string value and return the old value
      * @param key The key to set
      * @param value The value to set
-     * @param get Return the old string stored at key, or null if key did not exist
-     * @returns Promise that resolves with the old value, or null if key did not exist
+     * @param get Return the old string stored at key, or null if key did not
+     * exist
+     * @returns Promise that resolves with the old value, or null if key did not
+     * exist
      */
     set(key: RedisClient.KeyLike, value: RedisClient.KeyLike, get: "GET"): Promise<string | null>;
 
@@ -243,7 +255,8 @@ declare module "bun" {
     /**
      * Determine if a key exists
      * @param key The key to check
-     * @returns Promise that resolves with true if the key exists, false otherwise
+     * @returns Promise that resolves with true if the key exists, false
+     * otherwise
      */
     exists(key: RedisClient.KeyLike): Promise<boolean>;
 
@@ -258,7 +271,8 @@ declare module "bun" {
     /**
      * Get the time to live for a key in seconds
      * @param key The key to get the TTL for
-     * @returns Promise that resolves with the TTL, -1 if no expiry, or -2 if key doesn't exist
+     * @returns Promise that resolves with the TTL, -1 if no expiry, or -2 if
+     * key doesn't exist
      */
     ttl(key: RedisClient.KeyLike): Promise<number>;
 
@@ -290,7 +304,8 @@ declare module "bun" {
      * Check if a value is a member of a set
      * @param key The set key
      * @param member The member to check
-     * @returns Promise that resolves with true if the member exists, false otherwise
+     * @returns Promise that resolves with true if the member exists, false
+     * otherwise
      */
     sismember(key: RedisClient.KeyLike, member: string): Promise<boolean>;
 
@@ -298,7 +313,8 @@ declare module "bun" {
      * Add a member to a set
      * @param key The set key
      * @param member The member to add
-     * @returns Promise that resolves with 1 if the member was added, 0 if it already existed
+     * @returns Promise that resolves with 1 if the member was added, 0 if it
+     * already existed
      */
     sadd(key: RedisClient.KeyLike, member: string): Promise<number>;
 
@@ -306,7 +322,8 @@ declare module "bun" {
      * Remove a member from a set
      * @param key The set key
      * @param member The member to remove
-     * @returns Promise that resolves with 1 if the member was removed, 0 if it didn't exist
+     * @returns Promise that resolves with 1 if the member was removed, 0 if it
+     * didn't exist
      */
     srem(key: RedisClient.KeyLike, member: string): Promise<number>;
 
@@ -320,14 +337,16 @@ declare module "bun" {
     /**
      * Get a random member from a set
      * @param key The set key
-     * @returns Promise that resolves with a random member, or null if the set is empty
+     * @returns Promise that resolves with a random member, or null if the set
+     * is empty
      */
     srandmember(key: RedisClient.KeyLike): Promise<string | null>;
 
     /**
      * Remove and return a random member from a set
      * @param key The set key
-     * @returns Promise that resolves with the removed member, or null if the set is empty
+     * @returns Promise that resolves with the removed member, or null if the
+     * set is empty
      */
     spop(key: RedisClient.KeyLike): Promise<string | null>;
 
@@ -394,28 +413,32 @@ declare module "bun" {
     /**
      * Remove and get the first element in a list
      * @param key The list key
-     * @returns Promise that resolves with the first element, or null if the list is empty
+     * @returns Promise that resolves with the first element, or null if the
+     * list is empty
      */
     lpop(key: RedisClient.KeyLike): Promise<string | null>;
 
     /**
      * Remove the expiration from a key
      * @param key The key to persist
-     * @returns Promise that resolves with 1 if the timeout was removed, 0 if the key doesn't exist or has no timeout
+     * @returns Promise that resolves with 1 if the timeout was removed, 0 if
+     * the key doesn't exist or has no timeout
      */
     persist(key: RedisClient.KeyLike): Promise<number>;
 
     /**
      * Get the expiration time of a key as a UNIX timestamp in milliseconds
      * @param key The key to check
-     * @returns Promise that resolves with the timestamp, or -1 if the key has no expiration, or -2 if the key doesn't exist
+     * @returns Promise that resolves with the timestamp, or -1 if the key has
+     * no expiration, or -2 if the key doesn't exist
      */
     pexpiretime(key: RedisClient.KeyLike): Promise<number>;
 
     /**
      * Get the time to live for a key in milliseconds
      * @param key The key to check
-     * @returns Promise that resolves with the TTL in milliseconds, or -1 if the key has no expiration, or -2 if the key doesn't exist
+     * @returns Promise that resolves with the TTL in milliseconds, or -1 if the
+     * key has no expiration, or -2 if the key doesn't exist
      */
     pttl(key: RedisClient.KeyLike): Promise<number>;
 
@@ -429,42 +452,48 @@ declare module "bun" {
     /**
      * Get the number of members in a set
      * @param key The set key
-     * @returns Promise that resolves with the cardinality (number of elements) of the set
+     * @returns Promise that resolves with the cardinality (number of elements)
+     * of the set
      */
     scard(key: RedisClient.KeyLike): Promise<number>;
 
     /**
      * Get the length of the value stored in a key
      * @param key The key to check
-     * @returns Promise that resolves with the length of the string value, or 0 if the key doesn't exist
+     * @returns Promise that resolves with the length of the string value, or 0
+     * if the key doesn't exist
      */
     strlen(key: RedisClient.KeyLike): Promise<number>;
 
     /**
      * Get the number of members in a sorted set
      * @param key The sorted set key
-     * @returns Promise that resolves with the cardinality (number of elements) of the sorted set
+     * @returns Promise that resolves with the cardinality (number of elements)
+     * of the sorted set
      */
     zcard(key: RedisClient.KeyLike): Promise<number>;
 
     /**
      * Remove and return members with the highest scores in a sorted set
      * @param key The sorted set key
-     * @returns Promise that resolves with the removed member and its score, or null if the set is empty
+     * @returns Promise that resolves with the removed member and its score, or
+     * null if the set is empty
      */
     zpopmax(key: RedisClient.KeyLike): Promise<string | null>;
 
     /**
      * Remove and return members with the lowest scores in a sorted set
      * @param key The sorted set key
-     * @returns Promise that resolves with the removed member and its score, or null if the set is empty
+     * @returns Promise that resolves with the removed member and its score, or
+     * null if the set is empty
      */
     zpopmin(key: RedisClient.KeyLike): Promise<string | null>;
 
     /**
      * Get one or multiple random members from a sorted set
      * @param key The sorted set key
-     * @returns Promise that resolves with a random member, or null if the set is empty
+     * @returns Promise that resolves with a random member, or null if the set
+     * is empty
      */
     zrandmember(key: RedisClient.KeyLike): Promise<string | null>;
 
@@ -472,7 +501,8 @@ declare module "bun" {
      * Append a value to a key
      * @param key The key to append to
      * @param value The value to append
-     * @returns Promise that resolves with the length of the string after the append operation
+     * @returns Promise that resolves with the length of the string after the
+     * append operation
      */
     append(key: RedisClient.KeyLike, value: RedisClient.KeyLike): Promise<number>;
 
@@ -480,7 +510,8 @@ declare module "bun" {
      * Set the value of a key and return its old value
      * @param key The key to set
      * @param value The value to set
-     * @returns Promise that resolves with the old value, or null if the key didn't exist
+     * @returns Promise that resolves with the old value, or null if the key
+     * didn't exist
      */
     getset(key: RedisClient.KeyLike, value: RedisClient.KeyLike): Promise<string | null>;
 
@@ -488,7 +519,8 @@ declare module "bun" {
      * Prepend one or multiple values to a list
      * @param key The list key
      * @param value The value to prepend
-     * @returns Promise that resolves with the length of the list after the push operation
+     * @returns Promise that resolves with the length of the list after the push
+     * operation
      */
     lpush(key: RedisClient.KeyLike, value: RedisClient.KeyLike): Promise<number>;
 
@@ -496,7 +528,8 @@ declare module "bun" {
      * Prepend a value to a list, only if the list exists
      * @param key The list key
      * @param value The value to prepend
-     * @returns Promise that resolves with the length of the list after the push operation, or 0 if the list doesn't exist
+     * @returns Promise that resolves with the length of the list after the push
+     * operation, or 0 if the list doesn't exist
      */
     lpushx(key: RedisClient.KeyLike, value: RedisClient.KeyLike): Promise<number>;
 
@@ -504,7 +537,8 @@ declare module "bun" {
      * Add one or more members to a HyperLogLog
      * @param key The HyperLogLog key
      * @param element The element to add
-     * @returns Promise that resolves with 1 if the HyperLogLog was altered, 0 otherwise
+     * @returns Promise that resolves with 1 if the HyperLogLog was altered, 0
+     * otherwise
      */
     pfadd(key: RedisClient.KeyLike, element: string): Promise<number>;
 
@@ -512,7 +546,8 @@ declare module "bun" {
      * Append one or multiple values to a list
      * @param key The list key
      * @param value The value to append
-     * @returns Promise that resolves with the length of the list after the push operation
+     * @returns Promise that resolves with the length of the list after the push
+     * operation
      */
     rpush(key: RedisClient.KeyLike, value: RedisClient.KeyLike): Promise<number>;
 
@@ -520,7 +555,8 @@ declare module "bun" {
      * Append a value to a list, only if the list exists
      * @param key The list key
      * @param value The value to append
-     * @returns Promise that resolves with the length of the list after the push operation, or 0 if the list doesn't exist
+     * @returns Promise that resolves with the length of the list after the push
+     * operation, or 0 if the list doesn't exist
      */
     rpushx(key: RedisClient.KeyLike, value: RedisClient.KeyLike): Promise<number>;
 
@@ -528,7 +564,8 @@ declare module "bun" {
      * Set the value of a key, only if the key does not exist
      * @param key The key to set
      * @param value The value to set
-     * @returns Promise that resolves with 1 if the key was set, 0 if the key was not set
+     * @returns Promise that resolves with 1 if the key was set, 0 if the key
+     * was not set
      */
     setnx(key: RedisClient.KeyLike, value: RedisClient.KeyLike): Promise<number>;
 
@@ -536,14 +573,16 @@ declare module "bun" {
      * Get the score associated with the given member in a sorted set
      * @param key The sorted set key
      * @param member The member to get the score for
-     * @returns Promise that resolves with the score of the member as a string, or null if the member or key doesn't exist
+     * @returns Promise that resolves with the score of the member as a string,
+     * or null if the member or key doesn't exist
      */
     zscore(key: RedisClient.KeyLike, member: string): Promise<string | null>;
 
     /**
      * Get the values of all specified keys
      * @param keys The keys to get
-     * @returns Promise that resolves with an array of values, with null for keys that don't exist
+     * @returns Promise that resolves with an array of values, with null for
+     * keys that don't exist
      */
     mget(...keys: RedisClient.KeyLike[]): Promise<(string | null)[]>;
 
@@ -557,37 +596,46 @@ declare module "bun" {
     /**
      * Return a serialized version of the value stored at the specified key
      * @param key The key to dump
-     * @returns Promise that resolves with the serialized value, or null if the key doesn't exist
+     * @returns Promise that resolves with the serialized value, or null if the
+     * key doesn't exist
      */
     dump(key: RedisClient.KeyLike): Promise<string | null>;
 
     /**
      * Get the expiration time of a key as a UNIX timestamp in seconds
+     *
      * @param key The key to check
-     * @returns Promise that resolves with the timestamp, or -1 if the key has no expiration, or -2 if the key doesn't exist
+     * @returns Promise that resolves with the timestamp, or -1 if the key has
+     * no expiration, or -2 if the key doesn't exist
      */
     expiretime(key: RedisClient.KeyLike): Promise<number>;
 
     /**
      * Get the value of a key and delete the key
+     *
      * @param key The key to get and delete
-     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     * @returns Promise that resolves with the value of the key, or null if the
+     * key doesn't exist
      */
     getdel(key: RedisClient.KeyLike): Promise<string | null>;
 
     /**
      * Get the value of a key and optionally set its expiration
+     *
      * @param key The key to get
-     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     * @returns Promise that resolves with the value of the key, or null if the
+     * key doesn't exist
      */
     getex(key: RedisClient.KeyLike): Promise<string | null>;
 
     /**
      * Get the value of a key and set its expiration in seconds
+     *
      * @param key The key to get
      * @param ex Set the specified expire time, in seconds
      * @param seconds The number of seconds until expiration
-     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     * @returns Promise that resolves with the value of the key, or null if the
+     * key doesn't exist
      */
     getex(key: RedisClient.KeyLike, ex: "EX", seconds: number): Promise<string | null>;
 
@@ -602,6 +650,7 @@ declare module "bun" {
 
     /**
      * Get the value of a key and set its expiration at a specific Unix timestamp in seconds
+     *
      * @param key The key to get
      * @param exat Set the specified Unix time at which the key will expire, in seconds
      * @param timestampSeconds The Unix timestamp in seconds
@@ -611,6 +660,7 @@ declare module "bun" {
 
     /**
      * Get the value of a key and set its expiration at a specific Unix timestamp in milliseconds
+     *
      * @param key The key to get
      * @param pxat Set the specified Unix time at which the key will expire, in milliseconds
      * @param timestampMilliseconds The Unix timestamp in milliseconds
@@ -620,6 +670,7 @@ declare module "bun" {
 
     /**
      * Get the value of a key and remove its expiration
+     *
      * @param key The key to get
      * @param persist Remove the expiration from the key
      * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
@@ -634,10 +685,133 @@ declare module "bun" {
 
     /**
      *  Ping the server with a message
+     *
      *  @param message The message to send to the server
      *  @returns Promise that resolves with the message if the server is reachable, or throws an error if the server is not reachable
      */
     ping(message: RedisClient.KeyLike): Promise<string>;
+
+    /**
+     * Publish a message to a Redis channel.
+     *
+     * @param channel The channel to publish to.
+     * @param message The message to publish.
+     *
+     * @returns The number of clients that received the message. Note that in a
+     * cluster this returns the total number of clients in the same node.
+     */
+    publish(channel: string, message: string): Promise<number>;
+
+    /**
+     * Subscribe to a Redis channel.
+     *
+     * Subscribing disables automatic pipelining, so all commands will be
+     * received immediately.
+     *
+     * Subscribing moves the channel to a dedicated subscription state which
+     * prevents most other commands from being executed until unsubscribed. Only
+     * {@link ping `.ping()`}, {@link subscribe `.subscribe()`}, and
+     * {@link unsubscribe `.unsubscribe()`} are legal to invoke in a subscribed
+     * upon channel.
+     *
+     * @param channel The channel to subscribe to.
+     * @param listener The listener to call when a message is received on the
+     * channel. The listener will receive the message as the first argument and
+     * the channel as the second argument.
+     *
+     * @example
+     * ```ts
+     * await client.subscribe("my-channel", (message, channel) => {
+     *   console.log(`Received message on ${channel}: ${message}`);
+     * });
+     * ```
+     */
+    subscribe(channel: string, listener: RedisClient.StringPubSubListener): Promise<number>;
+
+    /**
+     * Subscribe to multiple Redis channels.
+     *
+     * Subscribing disables automatic pipelining, so all commands will be
+     * received immediately.
+     *
+     * Subscribing moves the channels to a dedicated subscription state in which
+     * only a limited set of commands can be executed.
+     *
+     * @param channels An array of channels to subscribe to.
+     * @param listener The listener to call when a message is received on any of
+     * the subscribed channels. The listener will receive the message as the
+     * first argument and the channel as the second argument.
+     */
+    subscribe(channels: string[], listener: RedisClient.StringPubSubListener): Promise<number>;
+
+    /**
+     * Unsubscribe from a singular Redis channel.
+     *
+     * @param channel The channel to unsubscribe from.
+     *
+     * If there are no more channels subscribed to, the client automatically
+     * re-enables pipelining if it was previously enabled.
+     *
+     * Unsubscribing moves the channel back to a normal state out of the
+     * subscription state if all channels have been unsubscribed from. For
+     * further details on the subscription state, see
+     * {@link subscribe `.subscribe()`}.
+     */
+    unsubscribe(channel: string): Promise<void>;
+
+    /**
+     * Remove a listener from a given Redis channel.
+     *
+     * If there are no more channels subscribed to, the client automatically
+     * re-enables pipelining if it was previously enabled.
+     *
+     * Unsubscribing moves the channel back to a normal state out of the
+     * subscription state if all channels have been unsubscribed from. For
+     * further details on the subscription state, see
+     * {@link subscribe `.subscribe()`}.
+     *
+     * @param channel The channel to unsubscribe from.
+     * @param listener The listener to remove. This is tested against
+     * referential equality so you must pass the exact same listener instance as
+     * when subscribing.
+     */
+    unsubscribe(channel: string, listener: RedisClient.StringPubSubListener): Promise<void>;
+
+    /**
+     * Unsubscribe from all registered Redis channels.
+     *
+     * The client will automatically re-enable pipelining if it was previously
+     * enabled.
+     *
+     * Unsubscribing moves the channel back to a normal state out of the
+     * subscription state if all channels have been unsubscribed from. For
+     * further details on the subscription state, see
+     * {@link subscribe `.subscribe()`}.
+     */
+    unsubscribe(): Promise<void>;
+
+    /**
+     * Unsubscribe from multiple Redis channels.
+     *
+     * @param channels An array of channels to unsubscribe from.
+     *
+     * If there are no more channels subscribed to, the client automatically
+     * re-enables pipelining if it was previously enabled.
+     *
+     * Unsubscribing moves the channel back to a normal state out of the
+     * subscription state if all channels have been unsubscribed from. For
+     * further details on the subscription state, see
+     * {@link subscribe `.subscribe()`}.
+     */
+    unsubscribe(channels: string[]): Promise<void>;
+
+    /**
+     * @brief Create a new RedisClient instance with the same configuration as
+     *        the current instance.
+     *
+     * This will open up a new connection to the Redis server.
+     */
+    duplicate(): Promise<RedisClient>;
   }
 
   /**

package/lib/sql.d.ts

@@ -12,6 +12,68 @@ declare module "bun" {
     release(): void;
   }
 
+  type ArrayType =
+    | "BOOLEAN"
+    | "BYTEA"
+    | "CHAR"
+    | "NAME"
+    | "TEXT"
+    | "CHAR"
+    | "VARCHAR"
+    | "SMALLINT"
+    | "INT2VECTOR"
+    | "INTEGER"
+    | "INT"
+    | "BIGINT"
+    | "REAL"
+    | "DOUBLE PRECISION"
+    | "NUMERIC"
+    | "MONEY"
+    | "OID"
+    | "TID"
+    | "XID"
+    | "CID"
+    | "JSON"
+    | "JSONB"
+    | "JSONPATH"
+    | "XML"
+    | "POINT"
+    | "LSEG"
+    | "PATH"
+    | "BOX"
+    | "POLYGON"
+    | "LINE"
+    | "CIRCLE"
+    | "CIDR"
+    | "MACADDR"
+    | "INET"
+    | "MACADDR8"
+    | "DATE"
+    | "TIME"
+    | "TIMESTAMP"
+    | "TIMESTAMPTZ"
+    | "INTERVAL"
+    | "TIMETZ"
+    | "BIT"
+    | "VARBIT"
+    | "ACLITEM"
+    | "PG_DATABASE"
+    | (string & {});
+
+  /**
+   * Represents a SQL array parameter
+   */
+  interface SQLArrayParameter {
+    /**
+     * The serialized values of the array parameter
+     */
+    serializedValues: string;
+    /**
+     * The type of the array parameter
+     */
+    arrayType: ArrayType;
+  }
+
   /**
    * Represents a client within a transaction context Extends SQL with savepoint
    * functionality
@@ -630,6 +692,21 @@ declare module "bun" {
      */
     reserve(): Promise<ReservedSQL>;
 
+    /**
+     * Creates a new SQL array parameter
+     * @param values - The values to create the array parameter from
+     * @param typeNameOrTypeID - The type name or type ID to create the array parameter from, if omitted it will default to JSON
+     * @returns A new SQL array parameter
+     *
+     * @example
+     * ```ts
+     * const array = sql.array([1, 2, 3], "INT");
+     * await sql`CREATE TABLE users_posts (user_id INT, posts_id INT[])`;
+     * await sql`INSERT INTO users_posts (user_id, posts_id) VALUES (${user.id}, ${array})`;
+     * ```
+     */
+    array(values: any[], typeNameOrTypeID?: number | ArrayType): SQLArrayParameter;
+
     /**
      * Begins a new transaction.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bun-types-no-globals",
-	"version": "1.2.23-canary.20250925T140721",
+	"version": "1.2.23-canary.20250927T140547",
 	"main": "./generator/index.ts",
 	"types": "./lib/index.d.ts",
 	"description": "TypeScript type definitions for Bun without global types pollution",