@depup/supabase__supabase-js 2.99.2-depup.0

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["DEFAULT_AUTH_OPTIONS: SupabaseAuthClientOptions","DEFAULT_REALTIME_OPTIONS: RealtimeClientOptions","fetch","DEFAULT_DB_OPTIONS","DEFAULT_AUTH_OPTIONS","DEFAULT_REALTIME_OPTIONS","DEFAULT_GLOBAL_OPTIONS","result: Required<SupabaseClientOptions<SchemaName>>","AuthClient","supabaseUrl: string","supabaseKey: string","PostgrestClient","SupabaseStorageClient","FunctionsClient","this","RealtimeClient"],"sources":["../src/lib/version.ts","../src/lib/constants.ts","../src/lib/fetch.ts","../src/lib/helpers.ts","../src/lib/SupabaseAuthClient.ts","../src/SupabaseClient.ts","../src/index.ts"],"sourcesContent":["// Generated automatically during releases by scripts/update-version-files.ts\n// This file provides runtime access to the package version for:\n// - HTTP request headers (e.g., X-Client-Info header for API requests)\n// - Debugging and support (identifying which version is running)\n// - Telemetry and logging (version reporting in errors/analytics)\n// - Ensuring build artifacts match the published package version\nexport const version = '2.99.2'\n","// constants.ts\nimport { RealtimeClientOptions } from '@supabase/realtime-js'\nimport { SupabaseAuthClientOptions } from './types'\nimport { version } from './version'\n\nlet JS_ENV = ''\n// @ts-ignore\nif (typeof Deno !== 'undefined') {\n  JS_ENV = 'deno'\n} else if (typeof document !== 'undefined') {\n  JS_ENV = 'web'\n} else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {\n  JS_ENV = 'react-native'\n} else {\n  JS_ENV = 'node'\n}\n\nexport const DEFAULT_HEADERS = { 'X-Client-Info': `supabase-js-${JS_ENV}/${version}` }\n\nexport const DEFAULT_GLOBAL_OPTIONS = {\n  headers: DEFAULT_HEADERS,\n}\n\nexport const DEFAULT_DB_OPTIONS = {\n  schema: 'public',\n}\n\nexport const DEFAULT_AUTH_OPTIONS: SupabaseAuthClientOptions = {\n  autoRefreshToken: true,\n  persistSession: true,\n  detectSessionInUrl: true,\n  flowType: 'implicit',\n}\n\nexport const DEFAULT_REALTIME_OPTIONS: RealtimeClientOptions = {}\n","type Fetch = typeof fetch\n\nexport const resolveFetch = (customFetch?: Fetch): Fetch => {\n  if (customFetch) {\n    return (...args: Parameters<Fetch>) => customFetch(...args)\n  }\n  return (...args: Parameters<Fetch>) => fetch(...args)\n}\n\nexport const resolveHeadersConstructor = () => {\n  return Headers\n}\n\nexport const fetchWithAuth = (\n  supabaseKey: string,\n  getAccessToken: () => Promise<string | null>,\n  customFetch?: Fetch\n): Fetch => {\n  const fetch = resolveFetch(customFetch)\n  const HeadersConstructor = resolveHeadersConstructor()\n\n  return async (input, init) => {\n    const accessToken = (await getAccessToken()) ?? supabaseKey\n    let headers = new HeadersConstructor(init?.headers)\n\n    if (!headers.has('apikey')) {\n      headers.set('apikey', supabaseKey)\n    }\n\n    if (!headers.has('Authorization')) {\n      headers.set('Authorization', `Bearer ${accessToken}`)\n    }\n\n    return fetch(input, { ...init, headers })\n  }\n}\n","// helpers.ts\nimport { SupabaseClientOptions } from './types'\n\nexport function uuid() {\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n    var r = (Math.random() * 16) | 0,\n      v = c == 'x' ? r : (r & 0x3) | 0x8\n    return v.toString(16)\n  })\n}\n\nexport function ensureTrailingSlash(url: string): string {\n  return url.endsWith('/') ? url : url + '/'\n}\n\nexport const isBrowser = () => typeof window !== 'undefined'\n\nexport function applySettingDefaults<\n  Database = any,\n  SchemaName extends string & keyof Database = 'public' extends keyof Database\n    ? 'public'\n    : string & keyof Database,\n>(\n  options: SupabaseClientOptions<SchemaName>,\n  defaults: SupabaseClientOptions<any>\n): Required<SupabaseClientOptions<SchemaName>> {\n  const {\n    db: dbOptions,\n    auth: authOptions,\n    realtime: realtimeOptions,\n    global: globalOptions,\n  } = options\n  const {\n    db: DEFAULT_DB_OPTIONS,\n    auth: DEFAULT_AUTH_OPTIONS,\n    realtime: DEFAULT_REALTIME_OPTIONS,\n    global: DEFAULT_GLOBAL_OPTIONS,\n  } = defaults\n\n  const result: Required<SupabaseClientOptions<SchemaName>> = {\n    db: {\n      ...DEFAULT_DB_OPTIONS,\n      ...dbOptions,\n    },\n    auth: {\n      ...DEFAULT_AUTH_OPTIONS,\n      ...authOptions,\n    },\n    realtime: {\n      ...DEFAULT_REALTIME_OPTIONS,\n      ...realtimeOptions,\n    },\n    storage: {},\n    global: {\n      ...DEFAULT_GLOBAL_OPTIONS,\n      ...globalOptions,\n      headers: {\n        ...(DEFAULT_GLOBAL_OPTIONS?.headers ?? {}),\n        ...(globalOptions?.headers ?? {}),\n      },\n    },\n    accessToken: async () => '',\n  }\n\n  if (options.accessToken) {\n    result.accessToken = options.accessToken\n  } else {\n    // hack around Required<>\n    delete (result as any).accessToken\n  }\n\n  return result\n}\n\n/**\n * Validates a Supabase client URL\n *\n * @param {string} supabaseUrl - The Supabase client URL string.\n * @returns {URL} - The validated base URL.\n * @throws {Error}\n */\nexport function validateSupabaseUrl(supabaseUrl: string): URL {\n  const trimmedUrl = supabaseUrl?.trim()\n\n  if (!trimmedUrl) {\n    throw new Error('supabaseUrl is required.')\n  }\n\n  if (!trimmedUrl.match(/^https?:\\/\\//i)) {\n    throw new Error('Invalid supabaseUrl: Must be a valid HTTP or HTTPS URL.')\n  }\n\n  try {\n    return new URL(ensureTrailingSlash(trimmedUrl))\n  } catch {\n    throw Error('Invalid supabaseUrl: Provided URL is malformed.')\n  }\n}\n","import { AuthClient } from '@supabase/auth-js'\nimport { SupabaseAuthClientOptions } from './types'\n\nexport class SupabaseAuthClient extends AuthClient {\n  constructor(options: SupabaseAuthClientOptions) {\n    super(options)\n  }\n}\n","import type { AuthChangeEvent } from '@supabase/auth-js'\nimport { FunctionsClient } from '@supabase/functions-js'\nimport {\n  PostgrestClient,\n  type PostgrestFilterBuilder,\n  type PostgrestQueryBuilder,\n} from '@supabase/postgrest-js'\nimport {\n  type RealtimeChannel,\n  type RealtimeChannelOptions,\n  RealtimeClient,\n  type RealtimeClientOptions,\n} from '@supabase/realtime-js'\nimport { StorageClient as SupabaseStorageClient } from '@supabase/storage-js'\nimport {\n  DEFAULT_AUTH_OPTIONS,\n  DEFAULT_DB_OPTIONS,\n  DEFAULT_GLOBAL_OPTIONS,\n  DEFAULT_REALTIME_OPTIONS,\n} from './lib/constants'\nimport { fetchWithAuth } from './lib/fetch'\nimport { applySettingDefaults, validateSupabaseUrl } from './lib/helpers'\nimport { SupabaseAuthClient } from './lib/SupabaseAuthClient'\nimport type {\n  Fetch,\n  GenericSchema,\n  SupabaseAuthClientOptions,\n  SupabaseClientOptions,\n} from './lib/types'\nimport { GetRpcFunctionFilterBuilderByArgs } from './lib/rest/types/common/rpc'\n\n/**\n * Supabase Client.\n *\n * An isomorphic Javascript client for interacting with Postgres.\n */\nexport default class SupabaseClient<\n  Database = any,\n  // The second type parameter is also used for specifying db_schema, so we\n  // support both cases.\n  // TODO: Allow setting db_schema from ClientOptions.\n  SchemaNameOrClientOptions extends\n    | (string & keyof Omit<Database, '__InternalSupabase'>)\n    | { PostgrestVersion: string } = 'public' extends keyof Omit<Database, '__InternalSupabase'>\n    ? 'public'\n    : string & keyof Omit<Database, '__InternalSupabase'>,\n  SchemaName extends string &\n    keyof Omit<Database, '__InternalSupabase'> = SchemaNameOrClientOptions extends string &\n    keyof Omit<Database, '__InternalSupabase'>\n    ? SchemaNameOrClientOptions\n    : 'public' extends keyof Omit<Database, '__InternalSupabase'>\n      ? 'public'\n      : string & keyof Omit<Omit<Database, '__InternalSupabase'>, '__InternalSupabase'>,\n  Schema extends Omit<Database, '__InternalSupabase'>[SchemaName] extends GenericSchema\n    ? Omit<Database, '__InternalSupabase'>[SchemaName]\n    : never = Omit<Database, '__InternalSupabase'>[SchemaName] extends GenericSchema\n    ? Omit<Database, '__InternalSupabase'>[SchemaName]\n    : never,\n  ClientOptions extends { PostgrestVersion: string } = SchemaNameOrClientOptions extends string &\n    keyof Omit<Database, '__InternalSupabase'>\n    ? // If the version isn't explicitly set, look for it in the __InternalSupabase object to infer the right version\n      Database extends { __InternalSupabase: { PostgrestVersion: string } }\n      ? Database['__InternalSupabase']\n      : // otherwise default to 12\n        { PostgrestVersion: '12' }\n    : SchemaNameOrClientOptions extends { PostgrestVersion: string }\n      ? SchemaNameOrClientOptions\n      : never,\n> {\n  /**\n   * Supabase Auth allows you to create and manage user sessions for access to data that is secured by access policies.\n   */\n  auth: SupabaseAuthClient\n  realtime: RealtimeClient\n  /**\n   * Supabase Storage allows you to manage user-generated content, such as photos or videos.\n   */\n  storage: SupabaseStorageClient\n\n  protected realtimeUrl: URL\n  protected authUrl: URL\n  protected storageUrl: URL\n  protected functionsUrl: URL\n  protected rest: PostgrestClient<Database, ClientOptions, SchemaName>\n  protected storageKey: string\n  protected fetch?: Fetch\n  protected changedAccessToken?: string\n  protected accessToken?: () => Promise<string | null>\n\n  protected headers: Record<string, string>\n\n  /**\n   * Create a new client for use in the browser.\n   *\n   * @category Initializing\n   *\n   * @param supabaseUrl The unique Supabase URL which is supplied when you create a new project in your project dashboard.\n   * @param supabaseKey The unique Supabase Key which is supplied when you create a new project in your project dashboard.\n   * @param options.db.schema You can switch in between schemas. The schema needs to be on the list of exposed schemas inside Supabase.\n   * @param options.auth.autoRefreshToken Set to \"true\" if you want to automatically refresh the token before expiring.\n   * @param options.auth.persistSession Set to \"true\" if you want to automatically save the user session into local storage.\n   * @param options.auth.detectSessionInUrl Set to \"true\" if you want to automatically detects OAuth grants in the URL and signs in the user.\n   * @param options.realtime Options passed along to realtime-js constructor.\n   * @param options.storage Options passed along to the storage-js constructor.\n   * @param options.global.fetch A custom fetch implementation.\n   * @param options.global.headers Any additional headers to send with each network request.\n   *\n   * @example Creating a client\n   * ```js\n   * import { createClient } from '@supabase/supabase-js'\n   *\n   * // Create a single supabase client for interacting with your database\n   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')\n   * ```\n   *\n   * @example With a custom domain\n   * ```js\n   * import { createClient } from '@supabase/supabase-js'\n   *\n   * // Use a custom domain as the supabase URL\n   * const supabase = createClient('https://my-custom-domain.com', 'publishable-or-anon-key')\n   * ```\n   *\n   * @example With additional parameters\n   * ```js\n   * import { createClient } from '@supabase/supabase-js'\n   *\n   * const options = {\n   *   db: {\n   *     schema: 'public',\n   *   },\n   *   auth: {\n   *     autoRefreshToken: true,\n   *     persistSession: true,\n   *     detectSessionInUrl: true\n   *   },\n   *   global: {\n   *     headers: { 'x-my-custom-header': 'my-app-name' },\n   *   },\n   * }\n   * const supabase = createClient(\"https://xyzcompany.supabase.co\", \"publishable-or-anon-key\", options)\n   * ```\n   *\n   * @exampleDescription With custom schemas\n   * By default the API server points to the `public` schema. You can enable other database schemas within the Dashboard.\n   * Go to [Settings > API > Exposed schemas](/dashboard/project/_/settings/api) and add the schema which you want to expose to the API.\n   *\n   * Note: each client connection can only access a single schema, so the code above can access the `other_schema` schema but cannot access the `public` schema.\n   *\n   * @example With custom schemas\n   * ```js\n   * import { createClient } from '@supabase/supabase-js'\n   *\n   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key', {\n   *   // Provide a custom schema. Defaults to \"public\".\n   *   db: { schema: 'other_schema' }\n   * })\n   * ```\n   *\n   * @exampleDescription Custom fetch implementation\n   * `supabase-js` uses the [`cross-fetch`](https://www.npmjs.com/package/cross-fetch) library to make HTTP requests,\n   * but an alternative `fetch` implementation can be provided as an option.\n   * This is most useful in environments where `cross-fetch` is not compatible (for instance Cloudflare Workers).\n   *\n   * @example Custom fetch implementation\n   * ```js\n   * import { createClient } from '@supabase/supabase-js'\n   *\n   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key', {\n   *   global: { fetch: fetch.bind(globalThis) }\n   * })\n   * ```\n   *\n   * @exampleDescription React Native options with AsyncStorage\n   * For React Native we recommend using `AsyncStorage` as the storage implementation for Supabase Auth.\n   *\n   * @example React Native options with AsyncStorage\n   * ```js\n   * import 'react-native-url-polyfill/auto'\n   * import { createClient } from '@supabase/supabase-js'\n   * import AsyncStorage from \"@react-native-async-storage/async-storage\";\n   *\n   * const supabase = createClient(\"https://xyzcompany.supabase.co\", \"publishable-or-anon-key\", {\n   *   auth: {\n   *     storage: AsyncStorage,\n   *     autoRefreshToken: true,\n   *     persistSession: true,\n   *     detectSessionInUrl: false,\n   *   },\n   * });\n   * ```\n   *\n   * @exampleDescription React Native options with Expo SecureStore\n   * If you wish to encrypt the user's session information, you can use `aes-js` and store the encryption key in Expo SecureStore.\n   * The `aes-js` library, a reputable JavaScript-only implementation of the AES encryption algorithm in CTR mode.\n   * A new 256-bit encryption key is generated using the `react-native-get-random-values` library.\n   * This key is stored inside Expo's SecureStore, while the value is encrypted and placed inside AsyncStorage.\n   *\n   * Please make sure that:\n   * - You keep the `expo-secure-store`, `aes-js` and `react-native-get-random-values` libraries up-to-date.\n   * - Choose the correct [`SecureStoreOptions`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestoreoptions) for your app's needs.\n   *   E.g. [`SecureStore.WHEN_UNLOCKED`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestorewhen_unlocked) regulates when the data can be accessed.\n   * - Carefully consider optimizations or other modifications to the above example, as those can lead to introducing subtle security vulnerabilities.\n   *\n   * @example React Native options with Expo SecureStore\n   * ```ts\n   * import 'react-native-url-polyfill/auto'\n   * import { createClient } from '@supabase/supabase-js'\n   * import AsyncStorage from '@react-native-async-storage/async-storage';\n   * import * as SecureStore from 'expo-secure-store';\n   * import * as aesjs from 'aes-js';\n   * import 'react-native-get-random-values';\n   *\n   * // As Expo's SecureStore does not support values larger than 2048\n   * // bytes, an AES-256 key is generated and stored in SecureStore, while\n   * // it is used to encrypt/decrypt values stored in AsyncStorage.\n   * class LargeSecureStore {\n   *   private async _encrypt(key: string, value: string) {\n   *     const encryptionKey = crypto.getRandomValues(new Uint8Array(256 / 8));\n   *\n   *     const cipher = new aesjs.ModeOfOperation.ctr(encryptionKey, new aesjs.Counter(1));\n   *     const encryptedBytes = cipher.encrypt(aesjs.utils.utf8.toBytes(value));\n   *\n   *     await SecureStore.setItemAsync(key, aesjs.utils.hex.fromBytes(encryptionKey));\n   *\n   *     return aesjs.utils.hex.fromBytes(encryptedBytes);\n   *   }\n   *\n   *   private async _decrypt(key: string, value: string) {\n   *     const encryptionKeyHex = await SecureStore.getItemAsync(key);\n   *     if (!encryptionKeyHex) {\n   *       return encryptionKeyHex;\n   *     }\n   *\n   *     const cipher = new aesjs.ModeOfOperation.ctr(aesjs.utils.hex.toBytes(encryptionKeyHex), new aesjs.Counter(1));\n   *     const decryptedBytes = cipher.decrypt(aesjs.utils.hex.toBytes(value));\n   *\n   *     return aesjs.utils.utf8.fromBytes(decryptedBytes);\n   *   }\n   *\n   *   async getItem(key: string) {\n   *     const encrypted = await AsyncStorage.getItem(key);\n   *     if (!encrypted) { return encrypted; }\n   *\n   *     return await this._decrypt(key, encrypted);\n   *   }\n   *\n   *   async removeItem(key: string) {\n   *     await AsyncStorage.removeItem(key);\n   *     await SecureStore.deleteItemAsync(key);\n   *   }\n   *\n   *   async setItem(key: string, value: string) {\n   *     const encrypted = await this._encrypt(key, value);\n   *\n   *     await AsyncStorage.setItem(key, encrypted);\n   *   }\n   * }\n   *\n   * const supabase = createClient(\"https://xyzcompany.supabase.co\", \"publishable-or-anon-key\", {\n   *   auth: {\n   *     storage: new LargeSecureStore(),\n   *     autoRefreshToken: true,\n   *     persistSession: true,\n   *     detectSessionInUrl: false,\n   *   },\n   * });\n   * ```\n   *\n   * @example With a database query\n   * ```ts\n   * import { createClient } from '@supabase/supabase-js'\n   *\n   * const supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key')\n   *\n   * const { data } = await supabase.from('profiles').select('*')\n   * ```\n   */\n  constructor(\n    protected supabaseUrl: string,\n    protected supabaseKey: string,\n    options?: SupabaseClientOptions<SchemaName>\n  ) {\n    const baseUrl = validateSupabaseUrl(supabaseUrl)\n    if (!supabaseKey) throw new Error('supabaseKey is required.')\n\n    this.realtimeUrl = new URL('realtime/v1', baseUrl)\n    this.realtimeUrl.protocol = this.realtimeUrl.protocol.replace('http', 'ws')\n    this.authUrl = new URL('auth/v1', baseUrl)\n    this.storageUrl = new URL('storage/v1', baseUrl)\n    this.functionsUrl = new URL('functions/v1', baseUrl)\n\n    // default storage key uses the supabase project ref as a namespace\n    const defaultStorageKey = `sb-${baseUrl.hostname.split('.')[0]}-auth-token`\n    const DEFAULTS = {\n      db: DEFAULT_DB_OPTIONS,\n      realtime: DEFAULT_REALTIME_OPTIONS,\n      auth: { ...DEFAULT_AUTH_OPTIONS, storageKey: defaultStorageKey },\n      global: DEFAULT_GLOBAL_OPTIONS,\n    }\n\n    const settings = applySettingDefaults(options ?? {}, DEFAULTS)\n\n    this.storageKey = settings.auth.storageKey ?? ''\n    this.headers = settings.global.headers ?? {}\n\n    if (!settings.accessToken) {\n      this.auth = this._initSupabaseAuthClient(\n        settings.auth ?? {},\n        this.headers,\n        settings.global.fetch\n      )\n    } else {\n      this.accessToken = settings.accessToken\n\n      this.auth = new Proxy<SupabaseAuthClient>({} as any, {\n        get: (_, prop) => {\n          throw new Error(\n            `@supabase/supabase-js: Supabase Client is configured with the accessToken option, accessing supabase.auth.${String(\n              prop\n            )} is not possible`\n          )\n        },\n      })\n    }\n\n    this.fetch = fetchWithAuth(supabaseKey, this._getAccessToken.bind(this), settings.global.fetch)\n    this.realtime = this._initRealtimeClient({\n      headers: this.headers,\n      accessToken: this._getAccessToken.bind(this),\n      ...settings.realtime,\n    })\n    if (this.accessToken) {\n      // Start auth immediately to avoid race condition with channel subscriptions\n      // Wrap Promise to avoid Firefox extension cross-context Promise access errors\n      Promise.resolve(this.accessToken())\n        .then((token) => this.realtime.setAuth(token))\n        .catch((e) => console.warn('Failed to set initial Realtime auth token:', e))\n    }\n\n    this.rest = new PostgrestClient(new URL('rest/v1', baseUrl).href, {\n      headers: this.headers,\n      schema: settings.db.schema,\n      fetch: this.fetch,\n      timeout: settings.db.timeout,\n      urlLengthLimit: settings.db.urlLengthLimit,\n    })\n\n    this.storage = new SupabaseStorageClient(\n      this.storageUrl.href,\n      this.headers,\n      this.fetch,\n      options?.storage\n    )\n\n    if (!settings.accessToken) {\n      this._listenForAuthEvents()\n    }\n  }\n\n  /**\n   * Supabase Functions allows you to deploy and invoke edge functions.\n   */\n  get functions(): FunctionsClient {\n    return new FunctionsClient(this.functionsUrl.href, {\n      headers: this.headers,\n      customFetch: this.fetch,\n    })\n  }\n\n  // NOTE: signatures must be kept in sync with PostgrestClient.from\n  from<\n    TableName extends string & keyof Schema['Tables'],\n    Table extends Schema['Tables'][TableName],\n  >(relation: TableName): PostgrestQueryBuilder<ClientOptions, Schema, Table, TableName>\n  from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(\n    relation: ViewName\n  ): PostgrestQueryBuilder<ClientOptions, Schema, View, ViewName>\n  /**\n   * Perform a query on a table or a view.\n   *\n   * @param relation - The table or view name to query\n   */\n  from(relation: string): PostgrestQueryBuilder<ClientOptions, Schema, any> {\n    return this.rest.from(relation)\n  }\n\n  // NOTE: signatures must be kept in sync with PostgrestClient.schema\n  /**\n   * Select a schema to query or perform an function (rpc) call.\n   *\n   * The schema needs to be on the list of exposed schemas inside Supabase.\n   *\n   * @param schema - The schema to query\n   */\n  schema<DynamicSchema extends string & keyof Omit<Database, '__InternalSupabase'>>(\n    schema: DynamicSchema\n  ): PostgrestClient<\n    Database,\n    ClientOptions,\n    DynamicSchema,\n    Database[DynamicSchema] extends GenericSchema ? Database[DynamicSchema] : any\n  > {\n    return this.rest.schema<DynamicSchema>(schema)\n  }\n\n  // NOTE: signatures must be kept in sync with PostgrestClient.rpc\n  /**\n   * Perform a function call.\n   *\n   * @param fn - The function name to call\n   * @param args - The arguments to pass to the function call\n   * @param options - Named parameters\n   * @param options.head - When set to `true`, `data` will not be returned.\n   * Useful if you only need the count.\n   * @param options.get - When set to `true`, the function will be called with\n   * read-only access mode.\n   * @param options.count - Count algorithm to use to count rows returned by the\n   * function. Only applicable for [set-returning\n   * functions](https://www.postgresql.org/docs/current/functions-srf.html).\n   *\n   * `\"exact\"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the\n   * hood.\n   *\n   * `\"planned\"`: Approximated but fast count algorithm. Uses the Postgres\n   * statistics under the hood.\n   *\n   * `\"estimated\"`: Uses exact count for low numbers and planned count for high\n   * numbers.\n   */\n  rpc<\n    FnName extends string & keyof Schema['Functions'],\n    Args extends Schema['Functions'][FnName]['Args'] = never,\n    FilterBuilder extends GetRpcFunctionFilterBuilderByArgs<\n      Schema,\n      FnName,\n      Args\n    > = GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args>,\n  >(\n    fn: FnName,\n    args: Args = {} as Args,\n    options: {\n      head?: boolean\n      get?: boolean\n      count?: 'exact' | 'planned' | 'estimated'\n    } = {\n      head: false,\n      get: false,\n      count: undefined,\n    }\n  ): PostgrestFilterBuilder<\n    ClientOptions,\n    Schema,\n    FilterBuilder['Row'],\n    FilterBuilder['Result'],\n    FilterBuilder['RelationName'],\n    FilterBuilder['Relationships'],\n    'RPC'\n  > {\n    return this.rest.rpc(fn, args, options) as unknown as PostgrestFilterBuilder<\n      ClientOptions,\n      Schema,\n      FilterBuilder['Row'],\n      FilterBuilder['Result'],\n      FilterBuilder['RelationName'],\n      FilterBuilder['Relationships'],\n      'RPC'\n    >\n  }\n\n  /**\n   * Creates a Realtime channel with Broadcast, Presence, and Postgres Changes.\n   *\n   * @param {string} name - The name of the Realtime channel.\n   * @param {Object} opts - The options to pass to the Realtime channel.\n   *\n   */\n  channel(name: string, opts: RealtimeChannelOptions = { config: {} }): RealtimeChannel {\n    return this.realtime.channel(name, opts)\n  }\n\n  /**\n   * Returns all Realtime channels.\n   */\n  getChannels(): RealtimeChannel[] {\n    return this.realtime.getChannels()\n  }\n\n  /**\n   * Unsubscribes and removes Realtime channel from Realtime client.\n   *\n   * @param {RealtimeChannel} channel - The name of the Realtime channel.\n   *\n   */\n  removeChannel(channel: RealtimeChannel): Promise<'ok' | 'timed out' | 'error'> {\n    return this.realtime.removeChannel(channel)\n  }\n\n  /**\n   * Unsubscribes and removes all Realtime channels from Realtime client.\n   */\n  removeAllChannels(): Promise<('ok' | 'timed out' | 'error')[]> {\n    return this.realtime.removeAllChannels()\n  }\n\n  private async _getAccessToken() {\n    if (this.accessToken) {\n      return await this.accessToken()\n    }\n\n    const { data } = await this.auth.getSession()\n\n    return data.session?.access_token ?? this.supabaseKey\n  }\n\n  private _initSupabaseAuthClient(\n    {\n      autoRefreshToken,\n      persistSession,\n      detectSessionInUrl,\n      storage,\n      userStorage,\n      storageKey,\n      flowType,\n      lock,\n      debug,\n      throwOnError,\n    }: SupabaseAuthClientOptions,\n    headers?: Record<string, string>,\n    fetch?: Fetch\n  ) {\n    const authHeaders = {\n      Authorization: `Bearer ${this.supabaseKey}`,\n      apikey: `${this.supabaseKey}`,\n    }\n    return new SupabaseAuthClient({\n      url: this.authUrl.href,\n      headers: { ...authHeaders, ...headers },\n      storageKey: storageKey,\n      autoRefreshToken,\n      persistSession,\n      detectSessionInUrl,\n      storage,\n      userStorage,\n      flowType,\n      lock,\n      debug,\n      throwOnError,\n      fetch,\n      // auth checks if there is a custom authorizaiton header using this flag\n      // so it knows whether to return an error when getUser is called with no session\n      hasCustomAuthorizationHeader: Object.keys(this.headers).some(\n        (key) => key.toLowerCase() === 'authorization'\n      ),\n    })\n  }\n\n  private _initRealtimeClient(options: RealtimeClientOptions) {\n    return new RealtimeClient(this.realtimeUrl.href, {\n      ...options,\n      params: { ...{ apikey: this.supabaseKey }, ...options?.params },\n    })\n  }\n\n  private _listenForAuthEvents() {\n    const data = this.auth.onAuthStateChange((event, session) => {\n      this._handleTokenChanged(event, 'CLIENT', session?.access_token)\n    })\n    return data\n  }\n\n  private _handleTokenChanged(\n    event: AuthChangeEvent,\n    source: 'CLIENT' | 'STORAGE',\n    token?: string\n  ) {\n    if (\n      (event === 'TOKEN_REFRESHED' || event === 'SIGNED_IN') &&\n      this.changedAccessToken !== token\n    ) {\n      this.changedAccessToken = token\n      this.realtime.setAuth(token)\n    } else if (event === 'SIGNED_OUT') {\n      this.realtime.setAuth()\n      if (source == 'STORAGE') this.auth.signOut()\n      this.changedAccessToken = undefined\n    }\n  }\n}\n","import SupabaseClient from './SupabaseClient'\nimport type { SupabaseClientOptions } from './lib/types'\n\nexport * from '@supabase/auth-js'\nexport type { User as AuthUser, Session as AuthSession } from '@supabase/auth-js'\nexport type {\n  PostgrestResponse,\n  PostgrestSingleResponse,\n  PostgrestMaybeSingleResponse,\n} from '@supabase/postgrest-js'\nexport { PostgrestError } from '@supabase/postgrest-js'\nexport type { FunctionInvokeOptions } from '@supabase/functions-js'\nexport {\n  FunctionsHttpError,\n  FunctionsFetchError,\n  FunctionsRelayError,\n  FunctionsError,\n  FunctionRegion,\n} from '@supabase/functions-js'\nexport * from '@supabase/realtime-js'\nexport { default as SupabaseClient } from './SupabaseClient'\nexport type {\n  SupabaseClientOptions,\n  QueryResult,\n  QueryData,\n  QueryError,\n  DatabaseWithoutInternals,\n} from './lib/types'\n\n/**\n * Creates a new Supabase Client.\n *\n * @example\n * ```ts\n * import { createClient } from '@supabase/supabase-js'\n *\n * const supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key')\n * const { data, error } = await supabase.from('profiles').select('*')\n * ```\n */\nexport const createClient = <\n  Database = any,\n  SchemaNameOrClientOptions extends\n    | (string & keyof Omit<Database, '__InternalSupabase'>)\n    | { PostgrestVersion: string } = 'public' extends keyof Omit<Database, '__InternalSupabase'>\n    ? 'public'\n    : string & keyof Omit<Database, '__InternalSupabase'>,\n  SchemaName extends string &\n    keyof Omit<Database, '__InternalSupabase'> = SchemaNameOrClientOptions extends string &\n    keyof Omit<Database, '__InternalSupabase'>\n    ? SchemaNameOrClientOptions\n    : 'public' extends keyof Omit<Database, '__InternalSupabase'>\n      ? 'public'\n      : string & keyof Omit<Omit<Database, '__InternalSupabase'>, '__InternalSupabase'>,\n>(\n  supabaseUrl: string,\n  supabaseKey: string,\n  options?: SupabaseClientOptions<SchemaName>\n): SupabaseClient<Database, SchemaNameOrClientOptions, SchemaName> => {\n  return new SupabaseClient<Database, SchemaNameOrClientOptions, SchemaName>(\n    supabaseUrl,\n    supabaseKey,\n    options\n  )\n}\n\n// Check for Node.js <= 18 deprecation\nfunction shouldShowDeprecationWarning(): boolean {\n  // Skip in browser environments\n  if (typeof window !== 'undefined') {\n    return false\n  }\n\n  // Skip if process is not available (e.g., Edge Runtime)\n  // Use dynamic property access to avoid Next.js Edge Runtime static analysis warnings\n  const _process = (globalThis as any)['process']\n  if (!_process) {\n    return false\n  }\n\n  const processVersion = _process['version']\n  if (processVersion === undefined || processVersion === null) {\n    return false\n  }\n\n  const versionMatch = processVersion.match(/^v(\\d+)\\./)\n  if (!versionMatch) {\n    return false\n  }\n\n  const majorVersion = parseInt(versionMatch[1], 10)\n  return majorVersion <= 18\n}\n\nif (shouldShowDeprecationWarning()) {\n  console.warn(\n    `⚠️  Node.js 18 and below are deprecated and will no longer be supported in future versions of @supabase/supabase-js. ` +\n      `Please upgrade to Node.js 20 or later. ` +\n      `For more information, visit: https://github.com/orgs/supabase/discussions/37217`\n  )\n}\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,564 @@
+import { FunctionInvokeOptions, FunctionRegion, FunctionsClient, FunctionsError, FunctionsFetchError, FunctionsHttpError, FunctionsRelayError } from "@supabase/functions-js";
+import { PostgrestClient, PostgrestError, PostgrestError as PostgrestError$1, PostgrestFilterBuilder, PostgrestMaybeSingleResponse, PostgrestQueryBuilder, PostgrestResponse, PostgrestSingleResponse } from "@supabase/postgrest-js";
+import { RealtimeChannel, RealtimeChannelOptions, RealtimeClient, RealtimeClientOptions } from "@supabase/realtime-js";
+import { StorageClient, StorageClientOptions } from "@supabase/storage-js";
+import { AuthClient, GoTrueClientOptions, Session as AuthSession, User as AuthUser } from "@supabase/auth-js";
+export * from "@supabase/realtime-js";
+export * from "@supabase/auth-js";
+
+//#region src/lib/rest/types/common/common.d.ts
+type GenericRelationship = {
+  foreignKeyName: string;
+  columns: string[];
+  isOneToOne?: boolean;
+  referencedRelation: string;
+  referencedColumns: string[];
+};
+type GenericTable = {
+  Row: Record<string, unknown>;
+  Insert: Record<string, unknown>;
+  Update: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericUpdatableView = {
+  Row: Record<string, unknown>;
+  Insert: Record<string, unknown>;
+  Update: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericNonUpdatableView = {
+  Row: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericView = GenericUpdatableView | GenericNonUpdatableView;
+type GenericSetofOption = {
+  isSetofReturn?: boolean | undefined;
+  isOneToOne?: boolean | undefined;
+  isNotNullable?: boolean | undefined;
+  to: string;
+  from: string;
+};
+type GenericFunction = {
+  Args: Record<string, unknown> | never;
+  Returns: unknown;
+  SetofOptions?: GenericSetofOption;
+};
+type GenericSchema = {
+  Tables: Record<string, GenericTable>;
+  Views: Record<string, GenericView>;
+  Functions: Record<string, GenericFunction>;
+};
+//#endregion
+//#region src/lib/types.d.ts
+interface SupabaseAuthClientOptions extends GoTrueClientOptions {}
+type Fetch = typeof fetch;
+type SupabaseClientOptions<SchemaName> = {
+  /**
+   * The Postgres schema which your tables belong to. Must be on the list of exposed schemas in Supabase. Defaults to `public`.
+   */
+  db?: {
+    schema?: SchemaName;
+    /**
+     * Optional timeout in milliseconds for PostgREST requests.
+     * When set, requests will automatically abort after this duration to prevent indefinite hangs.
+     *
+     * @example
+     * ```ts
+     * const supabase = createClient(url, key, {
+     *   db: { timeout: 30000 } // 30 second timeout
+     * })
+     * ```
+     */
+    timeout?: number;
+    /**
+     * Maximum URL length in characters before warnings/errors are triggered.
+     * Defaults to 8000 characters. Used to provide helpful hints when URLs
+     * exceed server limits.
+     *
+     * @example
+     * ```ts
+     * const supabase = createClient(url, key, {
+     *   db: { urlLengthLimit: 10000 } // Custom limit
+     * })
+     * ```
+     */
+    urlLengthLimit?: number;
+  };
+  auth?: {
+    /**
+     * Automatically refreshes the token for logged-in users. Defaults to true.
+     */
+    autoRefreshToken?: boolean;
+    /**
+     * Optional key name used for storing tokens in local storage.
+     */
+    storageKey?: string;
+    /**
+     * Whether to persist a logged-in session to storage. Defaults to true.
+     */
+    persistSession?: boolean;
+    /**
+     * Detect a session from the URL. Used for OAuth login callbacks. Defaults to true.
+     *
+     * Can be set to a function to provide custom logic for determining if a URL contains
+     * a Supabase auth callback. The function receives the current URL and parsed parameters,
+     * and should return true if the URL should be processed as a Supabase auth callback.
+     *
+     * This is useful when your app uses other OAuth providers (e.g., Facebook Login) that
+     * also return access_token in the URL fragment, which would otherwise be incorrectly
+     * intercepted by Supabase Auth.
+     *
+     * @example
+     * ```ts
+     * detectSessionInUrl: (url, params) => {
+     *   // Ignore Facebook OAuth redirects
+     *   if (url.pathname === '/facebook/redirect') return false
+     *   // Use default detection for other URLs
+     *   return Boolean(params.access_token || params.error_description)
+     * }
+     * ```
+     */
+    detectSessionInUrl?: boolean | ((url: URL, params: {
+      [parameter: string]: string;
+    }) => boolean);
+    /**
+     * A storage provider. Used to store the logged-in session.
+     */
+    storage?: SupabaseAuthClientOptions['storage'];
+    /**
+     * A storage provider to store the user profile separately from the session.
+     * Useful when you need to store the session information in cookies,
+     * without bloating the data with the redundant user object.
+     *
+     * @experimental
+     */
+    userStorage?: SupabaseAuthClientOptions['userStorage'];
+    /**
+     * OAuth flow to use - defaults to implicit flow. PKCE is recommended for mobile and server-side applications.
+     */
+    flowType?: SupabaseAuthClientOptions['flowType'];
+    /**
+     * If debug messages for authentication client are emitted. Can be used to inspect the behavior of the library.
+     */
+    debug?: SupabaseAuthClientOptions['debug'];
+    /**
+     * Provide your own locking mechanism based on the environment. By default no locking is done at this time.
+     *
+     * @experimental
+     */
+    lock?: SupabaseAuthClientOptions['lock'];
+    /**
+     * If there is an error with the query, throwOnError will reject the promise by
+     * throwing the error instead of returning it as part of a successful response.
+     */
+    throwOnError?: SupabaseAuthClientOptions['throwOnError'];
+  };
+  /**
+   * Options passed to the realtime-js instance
+   */
+  realtime?: RealtimeClientOptions;
+  storage?: StorageClientOptions;
+  global?: {
+    /**
+     * A custom `fetch` implementation.
+     */
+    fetch?: Fetch;
+    /**
+     * Optional headers for initializing the client.
+     */
+    headers?: Record<string, string>;
+  };
+  /**
+   * Optional function for using a third-party authentication system with
+   * Supabase. The function should return an access token or ID token (JWT) by
+   * obtaining it from the third-party auth SDK. Note that this
+   * function may be called concurrently and many times. Use memoization and
+   * locking techniques if this is not supported by the SDKs.
+   *
+   * When set, the `auth` namespace of the Supabase client cannot be used.
+   * Create another client if you wish to use Supabase Auth and third-party
+   * authentications concurrently in the same application.
+   */
+  accessToken?: () => Promise<string | null>;
+};
+/**
+ * Helper types for query results.
+ */
+type QueryResult<T> = T extends PromiseLike<infer U> ? U : never;
+type QueryData<T> = T extends PromiseLike<{
+  data: infer U;
+}> ? Exclude<U, null> : never;
+type QueryError = PostgrestError$1;
+/**
+ * Strips internal Supabase metadata from Database types.
+ * Useful for libraries defining generic constraints on Database types.
+ *
+ * @example
+ * ```typescript
+ * type CleanDB = DatabaseWithoutInternals<Database>
+ * ```
+ */
+type DatabaseWithoutInternals<DB> = Omit<DB, '__InternalSupabase'>;
+//#endregion
+//#region src/lib/SupabaseAuthClient.d.ts
+declare class SupabaseAuthClient extends AuthClient {
+  constructor(options: SupabaseAuthClientOptions);
+}
+//#endregion
+//#region src/lib/rest/types/common/rpc.d.ts
+type IsMatchingArgs<FnArgs extends GenericFunction['Args'], PassedArgs extends GenericFunction['Args']> = [FnArgs] extends [Record<PropertyKey, never>] ? PassedArgs extends Record<PropertyKey, never> ? true : false : keyof PassedArgs extends keyof FnArgs ? PassedArgs extends FnArgs ? true : false : false;
+type MatchingFunctionArgs<Fn$1 extends GenericFunction, Args extends GenericFunction['Args']> = Fn$1 extends {
+  Args: infer A extends GenericFunction['Args'];
+} ? IsMatchingArgs<A, Args> extends true ? Fn$1 : never : false;
+type FindMatchingFunctionByArgs<FnUnion, Args extends GenericFunction['Args']> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false;
+type TablesAndViews<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>;
+type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
+type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends (() => infer R) ? R : never;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false;
+type ExtractExactFunction<Fns, Args> = Fns extends infer F ? F extends GenericFunction ? ExactMatch<F['Args'], Args> extends true ? F : never : never : never;
+type IsNever<T> = [T] extends [never] ? true : false;
+type RpcFunctionNotFound<FnName> = {
+  Row: any;
+  Result: {
+    error: true;
+  } & "Couldn't infer function definition matching provided arguments";
+  RelationName: FnName;
+  Relationships: null;
+};
+type CrossSchemaError<TableRef extends string> = {
+  error: true;
+} & `Function returns SETOF from a different schema ('${TableRef}'). Use .overrideTypes<YourReturnType>() to specify the return type explicitly.`;
+type GetRpcFunctionFilterBuilderByArgs<Schema extends GenericSchema, FnName extends string & keyof Schema['Functions'], Args> = {
+  0: Schema['Functions'][FnName];
+  1: IsAny<Schema> extends true ? any : IsNever<Args> extends true ? IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true ? LastOf<Schema['Functions'][FnName]> : ExtractExactFunction<Schema['Functions'][FnName], Args> : Args extends Record<PropertyKey, never> ? LastOf<Schema['Functions'][FnName]> : Args extends GenericFunction['Args'] ? IsNever<LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>> extends true ? LastOf<Schema['Functions'][FnName]> : LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>> : ExtractExactFunction<Schema['Functions'][FnName], Args> extends GenericFunction ? ExtractExactFunction<Schema['Functions'][FnName], Args> : any;
+}[1] extends infer Fn ? IsAny<Fn> extends true ? {
+  Row: any;
+  Result: any;
+  RelationName: FnName;
+  Relationships: null;
+} : Fn extends GenericFunction ? {
+  Row: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] extends keyof TablesAndViews<Schema> ? TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row'] : Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : CrossSchemaError<Fn['SetofOptions']['to'] & string> : Fn['Returns'] extends Record<string, unknown> ? Fn['Returns'] : CrossSchemaError<Fn['SetofOptions']['to'] & string> : Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : never : Fn['Returns'] extends Record<string, unknown> ? Fn['Returns'] : never;
+  Result: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['isSetofReturn'] extends true ? Fn['SetofOptions']['isOneToOne'] extends true ? Fn['Returns'][] : Fn['Returns'] : Fn['Returns'] : Fn['Returns'];
+  RelationName: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] : FnName;
+  Relationships: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] extends keyof Schema['Tables'] ? Schema['Tables'][Fn['SetofOptions']['to']]['Relationships'] : Fn['SetofOptions']['to'] extends keyof Schema['Views'] ? Schema['Views'][Fn['SetofOptions']['to']]['Relationships'] : null : null;
+} : Fn extends false ? RpcFunctionNotFound<FnName> : RpcFunctionNotFound<FnName> : RpcFunctionNotFound<FnName>;
+//#endregion
+//#region src/SupabaseClient.d.ts
+/**
+ * Supabase Client.
+ *
+ * An isomorphic Javascript client for interacting with Postgres.
+ */
+declare class SupabaseClient<Database = any, SchemaNameOrClientOptions extends (string & keyof Omit<Database, '__InternalSupabase'>) | {
+  PostgrestVersion: string;
+} = ('public' extends keyof Omit<Database, '__InternalSupabase'> ? 'public' : string & keyof Omit<Database, '__InternalSupabase'>), SchemaName extends string & keyof Omit<Database, '__InternalSupabase'> = (SchemaNameOrClientOptions extends string & keyof Omit<Database, '__InternalSupabase'> ? SchemaNameOrClientOptions : 'public' extends keyof Omit<Database, '__InternalSupabase'> ? 'public' : string & keyof Omit<Omit<Database, '__InternalSupabase'>, '__InternalSupabase'>), Schema extends (Omit<Database, '__InternalSupabase'>[SchemaName] extends GenericSchema ? Omit<Database, '__InternalSupabase'>[SchemaName] : never) = (Omit<Database, '__InternalSupabase'>[SchemaName] extends GenericSchema ? Omit<Database, '__InternalSupabase'>[SchemaName] : never), ClientOptions extends {
+  PostgrestVersion: string;
+} = (SchemaNameOrClientOptions extends string & keyof Omit<Database, '__InternalSupabase'> ? Database extends {
+  __InternalSupabase: {
+    PostgrestVersion: string;
+  };
+} ? Database['__InternalSupabase'] : {
+  PostgrestVersion: '12';
+} : SchemaNameOrClientOptions extends {
+  PostgrestVersion: string;
+} ? SchemaNameOrClientOptions : never)> {
+  protected supabaseUrl: string;
+  protected supabaseKey: string;
+  /**
+   * Supabase Auth allows you to create and manage user sessions for access to data that is secured by access policies.
+   */
+  auth: SupabaseAuthClient;
+  realtime: RealtimeClient;
+  /**
+   * Supabase Storage allows you to manage user-generated content, such as photos or videos.
+   */
+  storage: StorageClient;
+  protected realtimeUrl: URL;
+  protected authUrl: URL;
+  protected storageUrl: URL;
+  protected functionsUrl: URL;
+  protected rest: PostgrestClient<Database, ClientOptions, SchemaName>;
+  protected storageKey: string;
+  protected fetch?: Fetch;
+  protected changedAccessToken?: string;
+  protected accessToken?: () => Promise<string | null>;
+  protected headers: Record<string, string>;
+  /**
+   * Create a new client for use in the browser.
+   *
+   * @category Initializing
+   *
+   * @param supabaseUrl The unique Supabase URL which is supplied when you create a new project in your project dashboard.
+   * @param supabaseKey The unique Supabase Key which is supplied when you create a new project in your project dashboard.
+   * @param options.db.schema You can switch in between schemas. The schema needs to be on the list of exposed schemas inside Supabase.
+   * @param options.auth.autoRefreshToken Set to "true" if you want to automatically refresh the token before expiring.
+   * @param options.auth.persistSession Set to "true" if you want to automatically save the user session into local storage.
+   * @param options.auth.detectSessionInUrl Set to "true" if you want to automatically detects OAuth grants in the URL and signs in the user.
+   * @param options.realtime Options passed along to realtime-js constructor.
+   * @param options.storage Options passed along to the storage-js constructor.
+   * @param options.global.fetch A custom fetch implementation.
+   * @param options.global.headers Any additional headers to send with each network request.
+   *
+   * @example Creating a client
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * // Create a single supabase client for interacting with your database
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+   * ```
+   *
+   * @example With a custom domain
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * // Use a custom domain as the supabase URL
+   * const supabase = createClient('https://my-custom-domain.com', 'publishable-or-anon-key')
+   * ```
+   *
+   * @example With additional parameters
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const options = {
+   *   db: {
+   *     schema: 'public',
+   *   },
+   *   auth: {
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: true
+   *   },
+   *   global: {
+   *     headers: { 'x-my-custom-header': 'my-app-name' },
+   *   },
+   * }
+   * const supabase = createClient("https://xyzcompany.supabase.co", "publishable-or-anon-key", options)
+   * ```
+   *
+   * @exampleDescription With custom schemas
+   * By default the API server points to the `public` schema. You can enable other database schemas within the Dashboard.
+   * Go to [Settings > API > Exposed schemas](/dashboard/project/_/settings/api) and add the schema which you want to expose to the API.
+   *
+   * Note: each client connection can only access a single schema, so the code above can access the `other_schema` schema but cannot access the `public` schema.
+   *
+   * @example With custom schemas
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key', {
+   *   // Provide a custom schema. Defaults to "public".
+   *   db: { schema: 'other_schema' }
+   * })
+   * ```
+   *
+   * @exampleDescription Custom fetch implementation
+   * `supabase-js` uses the [`cross-fetch`](https://www.npmjs.com/package/cross-fetch) library to make HTTP requests,
+   * but an alternative `fetch` implementation can be provided as an option.
+   * This is most useful in environments where `cross-fetch` is not compatible (for instance Cloudflare Workers).
+   *
+   * @example Custom fetch implementation
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key', {
+   *   global: { fetch: fetch.bind(globalThis) }
+   * })
+   * ```
+   *
+   * @exampleDescription React Native options with AsyncStorage
+   * For React Native we recommend using `AsyncStorage` as the storage implementation for Supabase Auth.
+   *
+   * @example React Native options with AsyncStorage
+   * ```js
+   * import 'react-native-url-polyfill/auto'
+   * import { createClient } from '@supabase/supabase-js'
+   * import AsyncStorage from "@react-native-async-storage/async-storage";
+   *
+   * const supabase = createClient("https://xyzcompany.supabase.co", "publishable-or-anon-key", {
+   *   auth: {
+   *     storage: AsyncStorage,
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: false,
+   *   },
+   * });
+   * ```
+   *
+   * @exampleDescription React Native options with Expo SecureStore
+   * If you wish to encrypt the user's session information, you can use `aes-js` and store the encryption key in Expo SecureStore.
+   * The `aes-js` library, a reputable JavaScript-only implementation of the AES encryption algorithm in CTR mode.
+   * A new 256-bit encryption key is generated using the `react-native-get-random-values` library.
+   * This key is stored inside Expo's SecureStore, while the value is encrypted and placed inside AsyncStorage.
+   *
+   * Please make sure that:
+   * - You keep the `expo-secure-store`, `aes-js` and `react-native-get-random-values` libraries up-to-date.
+   * - Choose the correct [`SecureStoreOptions`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestoreoptions) for your app's needs.
+   *   E.g. [`SecureStore.WHEN_UNLOCKED`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestorewhen_unlocked) regulates when the data can be accessed.
+   * - Carefully consider optimizations or other modifications to the above example, as those can lead to introducing subtle security vulnerabilities.
+   *
+   * @example React Native options with Expo SecureStore
+   * ```ts
+   * import 'react-native-url-polyfill/auto'
+   * import { createClient } from '@supabase/supabase-js'
+   * import AsyncStorage from '@react-native-async-storage/async-storage';
+   * import * as SecureStore from 'expo-secure-store';
+   * import * as aesjs from 'aes-js';
+   * import 'react-native-get-random-values';
+   *
+   * // As Expo's SecureStore does not support values larger than 2048
+   * // bytes, an AES-256 key is generated and stored in SecureStore, while
+   * // it is used to encrypt/decrypt values stored in AsyncStorage.
+   * class LargeSecureStore {
+   *   private async _encrypt(key: string, value: string) {
+   *     const encryptionKey = crypto.getRandomValues(new Uint8Array(256 / 8));
+   *
+   *     const cipher = new aesjs.ModeOfOperation.ctr(encryptionKey, new aesjs.Counter(1));
+   *     const encryptedBytes = cipher.encrypt(aesjs.utils.utf8.toBytes(value));
+   *
+   *     await SecureStore.setItemAsync(key, aesjs.utils.hex.fromBytes(encryptionKey));
+   *
+   *     return aesjs.utils.hex.fromBytes(encryptedBytes);
+   *   }
+   *
+   *   private async _decrypt(key: string, value: string) {
+   *     const encryptionKeyHex = await SecureStore.getItemAsync(key);
+   *     if (!encryptionKeyHex) {
+   *       return encryptionKeyHex;
+   *     }
+   *
+   *     const cipher = new aesjs.ModeOfOperation.ctr(aesjs.utils.hex.toBytes(encryptionKeyHex), new aesjs.Counter(1));
+   *     const decryptedBytes = cipher.decrypt(aesjs.utils.hex.toBytes(value));
+   *
+   *     return aesjs.utils.utf8.fromBytes(decryptedBytes);
+   *   }
+   *
+   *   async getItem(key: string) {
+   *     const encrypted = await AsyncStorage.getItem(key);
+   *     if (!encrypted) { return encrypted; }
+   *
+   *     return await this._decrypt(key, encrypted);
+   *   }
+   *
+   *   async removeItem(key: string) {
+   *     await AsyncStorage.removeItem(key);
+   *     await SecureStore.deleteItemAsync(key);
+   *   }
+   *
+   *   async setItem(key: string, value: string) {
+   *     const encrypted = await this._encrypt(key, value);
+   *
+   *     await AsyncStorage.setItem(key, encrypted);
+   *   }
+   * }
+   *
+   * const supabase = createClient("https://xyzcompany.supabase.co", "publishable-or-anon-key", {
+   *   auth: {
+   *     storage: new LargeSecureStore(),
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: false,
+   *   },
+   * });
+   * ```
+   *
+   * @example With a database query
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key')
+   *
+   * const { data } = await supabase.from('profiles').select('*')
+   * ```
+   */
+  constructor(supabaseUrl: string, supabaseKey: string, options?: SupabaseClientOptions<SchemaName>);
+  /**
+   * Supabase Functions allows you to deploy and invoke edge functions.
+   */
+  get functions(): FunctionsClient;
+  from<TableName extends string & keyof Schema['Tables'], Table extends Schema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder<ClientOptions, Schema, Table, TableName>;
+  from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder<ClientOptions, Schema, View, ViewName>;
+  /**
+   * Select a schema to query or perform an function (rpc) call.
+   *
+   * The schema needs to be on the list of exposed schemas inside Supabase.
+   *
+   * @param schema - The schema to query
+   */
+  schema<DynamicSchema extends string & keyof Omit<Database, '__InternalSupabase'>>(schema: DynamicSchema): PostgrestClient<Database, ClientOptions, DynamicSchema, Database[DynamicSchema] extends GenericSchema ? Database[DynamicSchema] : any>;
+  /**
+   * Perform a function call.
+   *
+   * @param fn - The function name to call
+   * @param args - The arguments to pass to the function call
+   * @param options - Named parameters
+   * @param options.head - When set to `true`, `data` will not be returned.
+   * Useful if you only need the count.
+   * @param options.get - When set to `true`, the function will be called with
+   * read-only access mode.
+   * @param options.count - Count algorithm to use to count rows returned by the
+   * function. Only applicable for [set-returning
+   * functions](https://www.postgresql.org/docs/current/functions-srf.html).
+   *
+   * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+   * hood.
+   *
+   * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+   * statistics under the hood.
+   *
+   * `"estimated"`: Uses exact count for low numbers and planned count for high
+   * numbers.
+   */
+  rpc<FnName extends string & keyof Schema['Functions'], Args extends Schema['Functions'][FnName]['Args'] = never, FilterBuilder extends GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args> = GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args>>(fn: FnName, args?: Args, options?: {
+    head?: boolean;
+    get?: boolean;
+    count?: 'exact' | 'planned' | 'estimated';
+  }): PostgrestFilterBuilder<ClientOptions, Schema, FilterBuilder['Row'], FilterBuilder['Result'], FilterBuilder['RelationName'], FilterBuilder['Relationships'], 'RPC'>;
+  /**
+   * Creates a Realtime channel with Broadcast, Presence, and Postgres Changes.
+   *
+   * @param {string} name - The name of the Realtime channel.
+   * @param {Object} opts - The options to pass to the Realtime channel.
+   *
+   */
+  channel(name: string, opts?: RealtimeChannelOptions): RealtimeChannel;
+  /**
+   * Returns all Realtime channels.
+   */
+  getChannels(): RealtimeChannel[];
+  /**
+   * Unsubscribes and removes Realtime channel from Realtime client.
+   *
+   * @param {RealtimeChannel} channel - The name of the Realtime channel.
+   *
+   */
+  removeChannel(channel: RealtimeChannel): Promise<'ok' | 'timed out' | 'error'>;
+  /**
+   * Unsubscribes and removes all Realtime channels from Realtime client.
+   */
+  removeAllChannels(): Promise<('ok' | 'timed out' | 'error')[]>;
+  private _getAccessToken;
+  private _initSupabaseAuthClient;
+  private _initRealtimeClient;
+  private _listenForAuthEvents;
+  private _handleTokenChanged;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Creates a new Supabase Client.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from '@supabase/supabase-js'
+ *
+ * const supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key')
+ * const { data, error } = await supabase.from('profiles').select('*')
+ * ```
+ */
+declare const createClient: <Database = any, SchemaNameOrClientOptions extends (string & keyof Omit<Database, "__InternalSupabase">) | {
+  PostgrestVersion: string;
+} = ("public" extends keyof Omit<Database, "__InternalSupabase"> ? "public" : string & keyof Omit<Database, "__InternalSupabase">), SchemaName extends string & keyof Omit<Database, "__InternalSupabase"> = (SchemaNameOrClientOptions extends string & keyof Omit<Database, "__InternalSupabase"> ? SchemaNameOrClientOptions : "public" extends keyof Omit<Database, "__InternalSupabase"> ? "public" : string & keyof Omit<Omit<Database, "__InternalSupabase">, "__InternalSupabase">)>(supabaseUrl: string, supabaseKey: string, options?: SupabaseClientOptions<SchemaName>) => SupabaseClient<Database, SchemaNameOrClientOptions, SchemaName>;
+//#endregion
+export { type AuthSession, type AuthUser, type DatabaseWithoutInternals, type FunctionInvokeOptions, FunctionRegion, FunctionsError, FunctionsFetchError, FunctionsHttpError, FunctionsRelayError, PostgrestError, type PostgrestMaybeSingleResponse, type PostgrestResponse, type PostgrestSingleResponse, type QueryData, type QueryError, type QueryResult, SupabaseClient, type SupabaseClientOptions, createClient };
+//# sourceMappingURL=index.d.cts.map