Supabase Csharp

https://github.com/supabase-community/supabase-csharp
Admin
Supabase Csharp is a .NET client library that provides seamless integration with Supabase services,...
Tokens:26,098
Snippets:289
Trust Score:8.8
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Unity Test Framework (Preview)

Source: https://github.com/supabase-community/supabase-csharp/wiki/Unity

Install a specific preview version of the Unity Test Framework that supports running async tests.

```bash
com.unity.test-framework
```

--------------------------------

### Initialize Supabase Client in C#

Source: https://github.com/supabase-community/supabase-csharp/wiki/Desktop-Clients

This snippet demonstrates the complete initialization process for the Supabase client in a C# application, including network status monitoring and authentication setup. It's adapted from a Unity example but applicable to other UI frameworks.

```csharp
using Supabase;
using Supabase.Gotrue;
using Supabase.Gotrue.Interfaces;
using Client = Supabase.Client;

private async void Initialize()
{
	// We create an object to monitor the network status.
    NetworkStatus NetworkStatus = new();

    // Create a Supabase objects object.
    SupabaseOptions options = new();
    // Set the options to auto-refresh the JWT token with a background thread.
    options.AutoRefreshToken = true;

    // Create the client object. Note that the project URL and the anon key are
    // available in the Supabase dashboard. In addition, note that the public anon
    // key is not a security risk - in JavaScript projects, this key is visible
    // in the browser viewing source!
    _supabase = new Client("https://project URL", "supabase PUBLIC anon key", options);
    
    // This adds a listener for debug information, especially useful for dealing
    // with errors from the auto-refresh background thread.
    _supabase.Auth.AddDebugListener(DebugListener);

    // Here we are getting the auth service and passing it to the network status
    // object. The network status object will tell the auth service when the
    // network is up or down.
    NetworkStatus.Client = (Supabase.Gotrue.Client)_supabase.Auth;

    // Here we are setting up the persistence layer. This is an object that implements
    // the IGotrueSessionPersistence<Session> interface. This is used to store the JWT 
    // token so the user won't have to log in every time they start the app.
    _supabase.Auth.SetPersistence(new UnitySession());
    
    // Here we are setting up the listener for the auth state. This listener will
    // be called in response to the auth state changing. This is where you would
    // update your UI to reflect the current auth state.
    _supabase.Auth.AddStateChangedListener(UnityAuthListener);
    
    // We now instruct the auth service to load the session from disk using the persistence
    // object we created earlier
    _supabase.Auth.LoadSession();
    
    // In this case, we are setting up the auth service to allow unconfirmed user sessions.
    // Depending on your use case, you may want to set this to false and require the user
    // to validate their email address before they can log in.
    _supabase.Auth.Options.AllowUnconfirmedUserSessions = true;

    // This is a well-known URL that is used to test network connectivity.
    // We use this to determine if the network is up or down.
    string url =
        $"{SupabaseSettings.SupabaseURL}/auth/v1/settings?apikey={SupabaseSettings.SupabaseAnonKey}";
    try
    {
        // We start the network status object. This will attempt to connect to the
        // well-known URL and determine if the network is up or down.
        _supabase!.Auth.Online = await NetworkStatus.StartAsync(url);
    }
    catch (NotSupportedException)
    {
        // On certain platforms, the NetworkStatus object may not be able to determine
        // the network status. In this case, we just assume the network is up.
        _supabase!.Auth.Online = true;
    }
    catch (Exception e)
    {
        // If there are other kinds of error, we assume the network is down,
        // and in this case we send the error to a UI element to display to the user.
        // This PostMessage method is specific to this application - you will
        // need to adapt this to your own application.
        PostMessage(NotificationType.Debug, "Network Error {e.GetType()}", e);
        _supabase!.Auth.Online = false;
    }
    if (_supabase.Auth.Online)
    {
        // If the network is up, we initialize the Supabase client.
        await _supabase.InitializeAsync();
        
        // Here we are fetching the current settings for the auth service as exposed
        // by the server. For example, we might want to know which providers have been
        // configured, or change the behavior if auto-confirm email is turned off or on.
        Settings = await _supabase.Auth.Settings();
    }
}
```

--------------------------------

### Install UniTask via Git URL

Source: https://github.com/supabase-community/supabase-csharp/wiki/Unity

Install the UniTask library for async/await support in Unity using its Git URL in the Package Manager.

```bash
https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask
```

--------------------------------

### Install Supabase.Gotrue via NuGet

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/README.md

Use the .NET CLI to add the package to your project.

```sh
dotnet add package Supabase.Gotrue
```

--------------------------------

### Install the NuGet package

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/extensions/DependencyInjection/README.md

Add the dependency to your .NET project using the dotnet CLI.

```sh
dotnet add package Supabase.Extensions.DependencyInjection
```

--------------------------------

### Install NuGet CLI on Windows

Source: https://github.com/supabase-community/supabase-csharp/wiki/Unity

Use Chocolatey to install the NuGet command-line interface on Windows.

```powershell
choco install nuget.commandline
```

--------------------------------

### Initialize and Use GoTrue Stateless Client

Source: https://github.com/supabase-community/supabase-csharp/wiki/Server-Side-Applications

This example demonstrates how to initialize a GoTrue stateless client and invite a user using a service role key. Ensure the service role key is kept secure as it grants administrative privileges.

```csharp
using static Supabase.Gotrue.StatelessClient;

IGotrueStatelessClient<User, Session> client = new StatelessClient();

var user = $"{RandomString(12)}@supabase.io";
var serviceRoleKey = GenerateServiceRoleToken();
var result = await _client.InviteUserByEmail(user, serviceRoleKey, Options);
```

--------------------------------

### Install NuGet CLI on macOS

Source: https://github.com/supabase-community/supabase-csharp/wiki/Unity

Use Homebrew to install the NuGet command-line interface on macOS.

```bash
brew install nuget
```

--------------------------------

### Install Supabase.Postgrest via NuGet

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Postgrest/README.md

Use the dotnet CLI to add the package to your project.

```sh
dotnet add package Supabase.Postgrest
```

--------------------------------

### Install Supabase Storage via CLI

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/README.md

Use the .NET CLI to add the Supabase.Storage package to your project.

```sh
dotnet add package Supabase.Storage
```

--------------------------------

### Install Supabase Functions package

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Functions/README.md

Use the dotnet CLI to add the package to your project.

```sh
dotnet add package Supabase.Functions
```

--------------------------------

### Install Supabase Realtime package

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Realtime/README.md

Use the .NET CLI to add the Supabase.Realtime package to your project.

```sh
dotnet add package Supabase.Realtime
```

--------------------------------

### Install Supabase NuGet Package

Source: https://github.com/supabase-community/supabase-csharp/blob/master/README.md

Use the .NET CLI to add the Supabase package to your project.

```sh
dotnet add package Supabase
```

--------------------------------

### Install Supabase C# Library on macOS

Source: https://github.com/supabase-community/supabase-csharp/wiki/Unity

Install the supabase-csharp NuGet package into your Unity project's Assets directory using the NuGet CLI.

```bash
nuget install supabase-csharp -OutputDirectory ./Assets/Supabase -Framework netstandard2.0
```

--------------------------------

### Install Supabase.Core via .NET CLI

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Core/README.md

Use this command to add the Supabase.Core package to your .NET project.

```sh
dotnet add package Supabase.Core
```

--------------------------------

### Install supabase-csharp NuGet Package

Source: https://github.com/supabase-community/supabase-csharp/wiki/Server-Side-Applications

Use this command to add the supabase-csharp library to your .NET project via the NuGet package manager.

```bash
dotnet add package supabase-csharp
```

--------------------------------

### Install NewtonsoftJson Support for Blazor WASM

Source: https://github.com/supabase-community/supabase-csharp/wiki/Desktop-Clients

For projects defaulting to System.Text.Json, such as Blazor WASM, install the NewtonsoftJson integration package. This is required for JSON serialization compatibility.

```bash
dotnet add package Microsoft.AspNetCore.Mvc.NewtonsoftJson --version 7.0.5
```

--------------------------------

### Accessing Supabase C# Client Services

Source: https://github.com/supabase-community/supabase-csharp/wiki/Home

Demonstrates how to get instances of various clients (Auth, Postgrest, Storage, Realtime) and invoke Supabase functions. This snippet covers common entry points for interacting with the Supabase backend.

```csharp
// Get the Auth Client
var auth = supabase.Auth;

// Get the Postgrest Client for a Model
var table = supabase.From<TModel>();

// Invoke an RPC Call
await supabase.Rpc("hello_world", null);

// Invoke a Supabase Function
await supabase.Functions.Invoke("custom_function");

// Get the Storage Client
var storageBucket = supabase.Storage.From("bucket_name");

// Use syntax for broadcast, presence, and postgres_changes
var realtime = supabase.Realtime.Channel("room_1");

// Alternatively, shortcut syntax for postgres_changes
await supabase.From<TModel>().On(ListenType.All, (sender, response) =>
{
    switch (response.Event)
    {
        case Constants.EventType.Insert:
            break;
        case Constants.EventType.Update:
            break;
        case Constants.EventType.Delete:
            break;
    }

    Debug.WriteLine($"[{response.Event}]:{response.Topic}:{response.Payload.Data}");
});
```

--------------------------------

### Registering Realtime Postgres Changes

Source: https://github.com/supabase-community/supabase-csharp/blob/master/docs/migrations/v8.0.0.md

Listeners must be registered before calling Subscribe(). The example demonstrates the transition from the previous behavior to the required v8.0.0 pattern.

```csharp
// Before (7.x) — the second listener was accepted but never fired
var channel = client.Realtime.Channel("public", "todos");
channel.OnPostgresChange(OnInsert, ListenType.Inserts);
await channel.Subscribe();
channel.OnPostgresChange(OnUpdate, ListenType.Updates); // silently ignored

// After (8.0.0) — register all listeners first
var channel = client.Realtime.Channel("public", "todos");
channel.OnPostgresChange(OnInsert, ListenType.Inserts);
channel.OnPostgresChange(OnUpdate, ListenType.Updates);
await channel.Subscribe();
```

--------------------------------

### Add Newtonsoft Json Package

Source: https://github.com/supabase-community/supabase-csharp/wiki/Unity

Install the Unity-specific version of the Newtonsoft JSON package via the Unity Package Manager by name.

```bash
com.unity.nuget.newtonsoft-json
```

--------------------------------

### Configure NewtonsoftJson in Initialization Code

Source: https://github.com/supabase-community/supabase-csharp/wiki/Desktop-Clients

After installing the NewtonsoftJson package, include this line in your application's initialization code to enable its use for JSON handling.

```csharp
builder.Services.AddControllers().AddNewtonsoftJson();
```

--------------------------------

### Initialize Supabase Client with Local Instance Options

Source: https://github.com/supabase-community/supabase-csharp/wiki/Home

This snippet shows how to initialize the Supabase client for a local instance. It also demonstrates signing up a new user.

```csharp
var options = new ClientOptions { Url = "https://example.com/api" };
var client = new Client(options);
var user = await client.SignUp("new-user@example.com");
```

--------------------------------

### Initialize Supabase Client

Source: https://github.com/supabase-community/supabase-csharp/blob/master/README.md

Configure the client with your URL and key, then initialize it to access Auth, Database, and Storage services.

```csharp
using Supabase;

var url = Environment.GetEnvironmentVariable("SUPABASE_URL");
var key = Environment.GetEnvironmentVariable("SUPABASE_KEY");

var options = new SupabaseOptions
{
    AutoRefreshToken = true,
    AutoConnectRealtime = true
};

var supabase = new Client(url, key, options);
await supabase.InitializeAsync();

// Auth
await supabase.Auth.SignIn("user@example.com", "password");

// Database
var movies = await supabase.From<Movie>().Get();

// Storage
await supabase.Storage.From("avatars").Download("me.png", null);
```

--------------------------------

### Initialize and Use the Gotrue Client

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/README.md

Configure the client with your project's auth URL and API key to perform authentication operations like signing up.

```csharp
using Supabase.Gotrue;

var client = new Client(new ClientOptions
{
    Url = "https://PROJECT_ID.supabase.co/auth/v1",
    Headers = new Dictionary<string, string> { { "apikey", SUPABASE_PUBLIC_KEY } }
});

var session = await client.SignUp("new-user@example.com", "password");
```

--------------------------------

### Initialize Supabase Storage Client

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/README.md

Create a new client instance by providing the storage URL and authentication headers.

```csharp
using Supabase.Storage;

var client = new Client("https://PROJECT_ID.supabase.co/storage/v1", new Dictionary<string, string>
{
    { "apikey", SUPABASE_KEY },
    { "Authorization", $"Bearer {SUPABASE_KEY}" }
});
```

--------------------------------

### Supabase.Gotrue.StatelessClient.SignUp

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

Registers a new user account.

```APIDOC
## SignUp

### Description
Registers a new user account.

### Signatures
- `Task<Session?> SignUp(SignUpType type, string identifier, string password, StatelessClientOptions options, SignUpOptions? signUpOptions = null)`
- `Task<Session?> SignUp(string email, string password, StatelessClientOptions options, SignUpOptions? signUpOptions = null)`
```

--------------------------------

### Initialize Supabase Stateless Client for Local Instance

Source: https://github.com/supabase-community/supabase-csharp/wiki/Home

This snippet demonstrates initializing and using a Supabase StatelessClient for local API interactions, including user sign-up.

```csharp
var options = new StatelessClientOptions { Url = "https://example.com/api" }
await new StatelessClient().SignUp("new-user@example.com", options);
```

--------------------------------

### Supabase.Client Constructor

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Supabase/Supabase/PublicAPI.Shipped.txt

Initializes a new instance of the Supabase client using the project URL and API key.

```APIDOC
## Supabase.Client(string supabaseUrl, string? supabaseKey, Supabase.SupabaseOptions? options)

### Description
Initializes the Supabase client with the required connection credentials and optional configuration.

### Parameters
- **supabaseUrl** (string) - Required - The URL of the Supabase project.
- **supabaseKey** (string) - Optional - The API key for the Supabase project.
- **options** (SupabaseOptions) - Optional - Configuration options for the client.
```

--------------------------------

### Build and Test Commands

Source: https://github.com/supabase-community/supabase-csharp/blob/master/README.md

Standard .NET CLI commands to restore dependencies, build the solution, and execute tests.

```sh
dotnet restore
dotnet build Supabase.sln --configuration Release
dotnet test  Supabase.sln --configuration Release
```

--------------------------------

### IGotrueStatelessClient.SignUp

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

Registers a new user account.

```APIDOC
## SignUp

### Description
Creates a new user account with the provided credentials and options.

### Signature
- `SignUp(SignUpType type, string identifier, string password, StatelessClientOptions options, SignUpOptions? signUpOptions = null) -> Task<TSession?>`
- `SignUp(string email, string password, StatelessClientOptions options, SignUpOptions? signUpOptions = null) -> Task<TSession?>`
```

--------------------------------

### Save Session Data to Cache

Source: https://github.com/supabase-community/supabase-csharp/wiki/Authorization-with-Gotrue

This C# method provides an example of saving session data to the user's cache directory using `Xamarin.Essentials`. It serializes the session object and writes it to a file. Ensure you implement corresponding load and destroy methods.

```csharp
// Add callback methods for above
// Here's a quick example of using this to save session data to the user's cache folder
// You'll want to add methods for loading the file and deleting when the user logs out 
internal bool SaveSession(Session session)
{
    var cacheFileName = ".gotrue.cache";
    
    try
    {
        var cacheDir = FileSystem.CacheDirectory;
        var path = Path.Join(cacheDir, cacheFileName);
        var str = JsonConvert.SerializeObject(session);

        using (StreamWriter file = new StreamWriter(path))
        {
            file.Write(str);
            file.Dispose();
            return Task.FromResult(true);
        };
    }
    catch (Exception err)
    {
        Debug.WriteLine("Unable to write cache file.");
        throw err;
    }
}
```

--------------------------------

### Connect and subscribe to Postgres changes

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Realtime/README.md

Initialize a client, connect to the socket, and subscribe to updates on a specific table. The client uses fail-fast behavior during initial connection.

```csharp
using Supabase.Realtime;

var client = new Client("ws://realtime-dev.localhost:4000/socket");
await client.ConnectAsync();

// Shorthand for a postgres_changes subscription: database, schema, table
var channel = client.Channel("realtime", "public", "todos");

channel.AddPostgresChangeHandler(ListenType.Updates, (_, change) =>
{
    var updated = change.Model<Todo>();
    var previous = change.OldModel<Todo>();
});

await channel.Subscribe();
```

--------------------------------

### Implement a raw ActivityListener

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/README.md

Demonstrates how to listen to Gotrue diagnostics without using the full OpenTelemetry SDK.

```csharp
using System.Diagnostics;
using Supabase.Gotrue;

using var listener = new ActivityListener
{
    ShouldListenTo = source => source.Name == GotrueDiagnostics.SourceName,
    Sample = (ref ActivityCreationOptions<ActivityContext> _) => ActivitySamplingResult.AllData,
    ActivityStopped = activity => Console.WriteLine($"{activity.OperationName} {activity.Duration.TotalMilliseconds}ms {activity.Status}")
};
ActivitySource.AddActivityListener(listener);
```

--------------------------------

### Implement a raw ActivityListener for observability

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/README.md

Demonstrates how to listen to storage activity without the OpenTelemetry SDK by using a raw ActivityListener.

```csharp
using System.Diagnostics;
using Supabase.Storage;

using var listener = new ActivityListener
{
    ShouldListenTo = source => source.Name == StorageDiagnostics.SourceName,
    Sample = (ref ActivityCreationOptions<ActivityContext> _) => ActivitySamplingResult.AllData,
    ActivityStopped = activity => Console.WriteLine($"{activity.OperationName} {activity.Duration.TotalMilliseconds}ms {activity.Status}")
};
ActivitySource.AddActivityListener(listener);
```

--------------------------------

### Native Sign in with Apple Flow in Unity

Source: https://github.com/supabase-community/supabase-csharp/wiki/Authorization-with-Gotrue

This C# code demonstrates the complete flow for native Sign in with Apple in Unity. It includes generating nonces, presenting the native dialog, handling callbacks, and signing into Supabase.

```csharp
// These are values that we will use to handle the flow.

// This is a one-time use code. It's used to verify the JWT from Apple.
private string? _nonce;

// This is a hash of the one-time use code. 
private string? _nonceVerify;

// This is the identity token from Apple.
private string? _identityToken;

// This is the authorization code from Apple.
private string? _authorizationCode;

// This method brings up the native dialog.
public void SignInWithApple()
{
    // This generates a random nonce (a one-time code) used to verify the JWT from
    // Apple.
    _nonce = Supabase.Gotrue.Helpers.GenerateNonce();
    
    // This is a SHA256 hash of the nonce.
    _nonceVerify = Supabase.Gotrue.Helpers.GenerateSHA256NonceFromRawNonce(_nonce);

    // Here we set the options for the native dialog, including the nonce.
    AppleAuthLoginArgs loginArgs =
        new(LoginOptions.IncludeEmail | LoginOptions.IncludeFullName, _nonceVerify);

    // Here we are asking the native dialog wrapper library to present the native
    // dialog. We are passing in the nonce and a callback to handle the results.
    _appleAuthManager!.LoginWithAppleId(loginArgs, SuccessCallback, ErrorCallback);
}

// This method handles the callback from the native dialog and sets the data
// to be used later.
private void SuccessCallback(ICredential credential)
{
    // Obtained credential, cast it to IAppleIDCredential
    if (credential is IAppleIDCredential appleIdCredential)
    {
        // Apple User ID
        string? userId = appleIdCredential.User;

        // Email and first name are received ONLY in the first login
        // You may want to add logic to save these fields locally

        // Identity token
        _identityToken = Encoding.UTF8.GetString(appleIdCredential.IdentityToken, 0,
            appleIdCredential.IdentityToken.Length);

        // Authorization code
        _authorizationCode = Encoding.UTF8.GetString(appleIdCredential.AuthorizationCode, 0,
            appleIdCredential.AuthorizationCode.Length);

        // And now you have all the information to create/login a user in your system
        _doAppleSignIn = true;
    }
    else
    {
        // Error handling - you don't want to use Sign in with Apple on non Apple devices
    }
}

// Now we use an Update() declared async.
private async void Update()
{
    // Updates the AppleAuthManager instance to execute
    // pending callbacks inside Unity's execution loop
    _appleAuthManager?.Update();

    if (_doAppleSignIn)
    {
        _doAppleSignIn = false;
        // ReSharper disable once Unity.PerformanceCriticalCodeInvocation
        bool status = await SignInToSupabaseWithApple();
        if (!status)
            Debug.Log("Sign in failed", gameObject);
        _doAppleSignIn = false;
    }
}

// This method takes the data from the callback and sends it to Supabase to
// validate the JWT and create a Supabase session. Note that because this method
// goes over the network, it's declared async. In Unity this means you might want
// to call this method from an Update method marked async.
private async Task<bool> SignInToSupabaseWithApple()
{
    try
    {
        Session? session = await SupabaseManager.Client()?.Auth.SignInWithIdToken(Constants.Provider.Apple, _identityToken!, _nonce)!;
        if (session?.User?.Id != null)
        {
            // You logged in successfully! Depending on your application you may want to load another scene, etc.
        }
        else
        {
            // Something went wrong - you may want to display an error message to the user.
        }
    }
    catch (GotrueException e)
    {
        // Something went wrong - you may want to display an error message to the user. GotrueExceptions
        // generally mean the server sent back an error message.
    }
    catch (Exception e)
    {
        // Catch-all for anything else that might have gone wrong.
    }
    return true;
}

```

--------------------------------

### Initialize Supabase Auth Client with Public Key

Source: https://github.com/supabase-community/supabase-csharp/wiki/Home

Use this snippet to initialize the Supabase Auth client when using the Supabase Hosted service from an untrusted client. Ensure you replace 'PROJECT_ID' and 'SUPABASE_PUBLIC_KEY' with your actual project details.

```csharp
var auth = new Supabase.Gotrue.Client(new ClientOptions<Session>
{
    Url = "https://PROJECT_ID.supabase.co/auth/v1",
    Headers = new Dictionary<string, string>
    {
        { "apikey", SUPABASE_PUBLIC_KEY }
    }
})
```

--------------------------------

### Invoke a Supabase Function

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Functions/README.md

Initialize the client with your project URL and invoke a function by name, providing an authorization token.

```csharp
using Supabase.Functions;

var client = new Client("https://PROJECT_ID.supabase.co/functions/v1");

// Invoke and read the raw string response.
var body = await client.Invoke("hello-world", token: SUPABASE_ANON_KEY);
```

--------------------------------

### Realtime Localhost Configuration

Source: https://github.com/supabase-community/supabase-csharp/blob/master/README.md

Required hosts file entry to enable local Realtime test suite execution.

```text
127.0.0.1  realtime-dev.localhost
```

--------------------------------

### Initialize Supabase Auth Client with Offline Support

Source: https://github.com/supabase-community/supabase-csharp/wiki/Authorization-with-Gotrue

This snippet shows how to create a Supabase Auth client with offline capabilities enabled and integrate it with the NetworkStatus monitor. Ensure the client is configured with `AllowUnconfirmedUserSessions` if needed.

```csharp
// Create the client
var client = new Client(new ClientOptions { AllowUnconfirmedUserSessions = true });
// Create the network status monitor
var status = new NetworkStatus();
// Tell the network status monitor to update the client's online status
status.Client = client;
// Start the network status monitor
await status.StartAsync();
// rest of the usual client configuration
```

--------------------------------

### Implement OAuth PKCE Flow

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/README.md

Initiates a PKCE-based OAuth sign-in and exchanges the authorization code for a session in the callback.

```csharp
var state = await client.SignIn(Constants.Provider.Github, new SignInOptions
{
    FlowType = Constants.OAuthFlowType.PKCE,
    RedirectTo = "http://localhost:3000/oauth/callback"
});

// Send the user to state.Uri, and stash state.PKCEVerifier for the callback.

// In the callback (URL is http://REDIRECT_TO_URL?code=CODE):
var session = await client.ExchangeCodeForSession(state.PKCEVerifier, code);
```

--------------------------------

### Supabase.Realtime.ClientOptions

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Realtime/Realtime/PublicAPI.Shipped.txt

Configuration options for the Realtime client, including heartbeat intervals, timeouts, and transport settings.

```APIDOC
## Supabase.Realtime.ClientOptions

### Properties
- `DateTimeFormat` (string): Gets or sets the date-time format.
- `EventsPerSecond` (int): Gets or sets the rate limit for events.
- `HeartbeatInterval` (TimeSpan): Gets or sets the interval for heartbeat pings.
- `Timeout` (TimeSpan): Gets or sets the connection timeout duration.
- `Transport` (string): Gets or sets the transport protocol.
```

--------------------------------

### Initiate PKCE OAuth Flow with GitHub

Source: https://github.com/supabase-community/supabase-csharp/wiki/Authorization-with-Gotrue

Initiates the OAuth flow for GitHub using the PKCE type. Ensure the RedirectTo URL is configured in your Supabase project settings.

```csharp
var state = await client.SignIn(Constants.Provider.Github, new SignInOptions
{
    FlowType = Constants.OAuthFlowType.PKCE,
    RedirectTo = "http://localhost:3000/oauth/callback"
});
```

--------------------------------

### Implement a raw ActivityListener

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Postgrest/README.md

Captures Postgrest diagnostic events without requiring the full OpenTelemetry SDK.

```csharp
using System.Diagnostics;
using Supabase.Postgrest;

using var listener = new ActivityListener
{
    ShouldListenTo = source => source.Name == PostgrestDiagnostics.SourceName,
    Sample = (ref ActivityCreationOptions<ActivityContext> _) => ActivitySamplingResult.AllData,
    ActivityStopped = activity => Console.WriteLine($"{activity.OperationName} {activity.Duration.TotalMilliseconds}ms {activity.Status}")
};
ActivitySource.AddActivityListener(listener);
```

--------------------------------

### Prepare Identity Token for Google Sign-In

Source: https://github.com/supabase-community/supabase-csharp/wiki/Authorization-with-Gotrue

Prepares the identity token received from a Google Sign-In implementation for use with Supabase. Ensure User Signups are enabled in Supabase project settings.

```csharp
var identityToken = Encoding.UTF8.GetString(System.Text.Encoding.UTF8.GetBytes(GoogleIdToken), 0, GoogleIdToken.Length);
```

--------------------------------

### Sign in with SSO

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/README.md

Initiates an SSO sign-in flow and retrieves a session from the resulting redirect URL.

```csharp
var ssoResponse = await client.SignInWithSSO("supabase.io", new SignInWithSSOOptions
{
    RedirectTo = "https://localhost:3000/welcome"
});

// Send the user to ssoResponse.Uri. On return (URL carries the session), exchange it:
var session = await client.GetSessionFromUrl(url);
```

--------------------------------

### Configure Client for Supabase Hosted Service

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Postgrest/README.md

Provide API keys and authorization tokens via headers when connecting to a hosted Supabase instance.

```csharp
var options = new ClientOptions();
var client = new Client("https://PROJECT_ID.supabase.co/rest/v1", options)
{
    GetHeaders = () => new Dictionary<string, string>
    {
        { "apikey", SUPABASE_PUBLIC_KEY },
        { "Authorization", $"Bearer {SUPABASE_USER_TOKEN}" }
    }
};
```

--------------------------------

### Configure OpenTelemetry for Postgrest

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Postgrest/README.md

Registers the Postgrest ActivitySource and Meter with the OpenTelemetry SDK using the provided constants.

```csharp
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;
using Supabase.Postgrest;

// Requires OpenTelemetry.Extensions.Hosting and an exporter package (e.g. OTLP) in your app.
builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddSource(PostgrestDiagnostics.SourceName)
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddMeter(PostgrestDiagnostics.SourceName)
        .AddOtlpExporter());
```

--------------------------------

### Configure OpenTelemetry for observability

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Functions/README.md

Register the client's ActivitySource and Meter with OpenTelemetry to capture traces and metrics.

```csharp
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;
using Supabase.Functions;

// Requires OpenTelemetry.Extensions.Hosting and an exporter package (e.g. OTLP) in your app.
builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddSource(FunctionsDiagnostics.SourceName)
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddMeter(FunctionsDiagnostics.SourceName)
        .AddOtlpExporter());
```

--------------------------------

### Authentication Methods

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

Methods for signing in, signing up, and managing user sessions.

```APIDOC
## SignInWithEmail
### Description
Signs in a user using their email and password.
### Signature
Task<Session?> SignInWithEmail(string email, string password)

## SignUpWithEmail
### Description
Registers a new user with an email and password.
### Signature
Task<Session?> SignUpWithEmail(string email, string password, SignUpOptions? options = null)

## SignOut
### Description
Signs out the current user.
### Signature
Task<BaseResponse> SignOut(string jwt, Constants.SignOutScope scope = Constants.SignOutScope.Global)
```

--------------------------------

### Supabase.StatelessClient.From<T>

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Supabase/Supabase/PublicAPI.Shipped.txt

Initializes a table client for a specific model type.

```APIDOC
## From<T>(string supabaseUrl, string supabaseKey, SupabaseOptions? options)

### Description
Creates a table client instance for the specified model type to perform database operations.

### Parameters
- **supabaseUrl** (string) - Required - The Supabase project URL.
- **supabaseKey** (string) - Required - The Supabase API key.
- **options** (SupabaseOptions) - Optional - Configuration options for the client.
```

--------------------------------

### Register Supabase in Dependency Injection

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/extensions/DependencyInjection/README.md

Configure the Supabase client and options within the service collection.

```csharp
builder.Services.AddSupabase(
    supabaseUrl: "https://xyz.supabase.co",
    supabaseKey: builder.Configuration["Supabase:Key"]!,
    configureOptions: options =>
    {
        options.AutoConnectRealtime = true;
        options.PostgrestRetry = new RetryOptions { MaxRetries = 3 };
    });
```

--------------------------------

### Configure OpenTelemetry Observability

Source: https://github.com/supabase-community/supabase-csharp/blob/master/README.md

Register Supabase diagnostic sources with OpenTelemetry to enable tracing and metrics.

```csharp
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;
using Supabase;

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddSource(SupabaseDiagnostics.SourceNames.ToArray())
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddMeter(SupabaseDiagnostics.SourceNames.ToArray())
        .AddOtlpExporter());
```

--------------------------------

### IGotrueClient Authentication Methods

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

Methods for signing in, signing up, and signing out users.

```APIDOC
## SignIn

### Description
Signs in a user using email or passwordless options.

### Signature
- `SignIn(string email, SignInOptions? options = null) -> Task<bool>`
- `SignIn(string email, string password) -> Task<TSession?>`
- `SignInWithPassword(string email, string password) -> Task<TSession?>`
- `SignInAnonymously(SignInAnonymouslyOptions? options = null) -> Task<TSession?>`
- `SignInWithOtp(SignInWithPasswordlessEmailOptions options) -> Task<PasswordlessSignInState>`
- `SignInWithOtp(SignInWithPasswordlessPhoneOptions options) -> Task<PasswordlessSignInState>`
- `SignInWithSSO(Guid providerId, SignInWithSSOOptions? options = null) -> Task<SSOResponse?>`
- `SignInWithSSO(string domain, SignInWithSSOOptions? options = null) -> Task<SSOResponse?>`
- `SignInWithIdToken(Provider provider, string idToken, string? accessToken = null, string? nonce = null, string? captchaToken = null) -> Task<TSession?>`
```

```APIDOC
## SignUp

### Description
Registers a new user account.

### Signature
- `SignUp(SignUpType type, string identifier, string password, SignUpOptions? options = null) -> Task<TSession?>`
- `SignUp(string email, string password, SignUpOptions? options = null) -> Task<TSession?>`
```

```APIDOC
## SignOut

### Description
Signs out the current user.

### Signature
- `SignOut(SignOutScope scope = SignOutScope.Global) -> Task`
```

--------------------------------

### IStorageFileApi.Download

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/Storage/PublicAPI.Shipped.txt

Downloads a file from a specified path in the storage bucket.

```APIDOC
## Download(string supabasePath, ...)

### Description
Downloads a file from the storage bucket to a byte array or a local file path.

### Parameters
- **supabasePath** (string) - Required - The path of the file in storage.
- **localPath** (string) - Optional - The local file system path to save the downloaded file.
- **transformOptions** (TransformOptions) - Optional - Image transformation options.
- **onProgress** (EventHandler<float>) - Optional - Progress tracking event handler.
```

--------------------------------

### IGotrueClient.Challenge

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

Initiates an MFA challenge for a user.

```APIDOC
## Challenge(MfaChallengeParams mfaChallengeParams)

### Description
Initiates an MFA challenge using the provided parameters.

### Parameters
- **mfaChallengeParams** (MfaChallengeParams) - Required - The parameters required to initiate the MFA challenge.

### Returns
- **Task<MfaChallengeResponse?>** - A task that resolves to the MFA challenge response.
```

--------------------------------

### Repository Package Layout

Source: https://github.com/supabase-community/supabase-csharp/blob/master/README.md

Visual representation of the directory structure and corresponding NuGet packages for the Supabase C# SDK.

```text
packages/
  Supabase/    The unified client (NuGet: Supabase)
  Gotrue/      Auth        (NuGet: Supabase.Gotrue)
  Postgrest/   Database    (NuGet: Supabase.Postgrest)
  Storage/     Storage     (NuGet: Supabase.Storage)
  Realtime/    Realtime    (NuGet: Supabase.Realtime)
  Functions/   Functions   (NuGet: Supabase.Functions)
  Core/        Shared      (NuGet: Supabase.Core)
```

--------------------------------

### Initialize Gotrue with Session Persistence

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/README.md

Configures the client with custom persistence callbacks to enable session restoration and automatic token refreshing.

```csharp
async void Initialize()
{
    var persistence = new GotrueSessionPersistence(SaveSession, LoadSession, DestroySession);
    var client = new Client(new ClientOptions
    {
        Url = GOTRUE_URL,
        AllowUnconfirmedUserSessions = true,
        SessionPersistence = persistence
    });

    // Listen to token-refresh problems and auth-state changes.
    client.AddDebugListener(LogDebug);
    client.AddStateChangedListener(AuthStateListener);

    // Restore a persisted session and refresh it.
    client.LoadSession();
    await client.RetrieveSessionAsync();
}

// Example: persist the session to the user's cache folder.
bool SaveSession(Session session)
{
    var path = Path.Join(FileSystem.CacheDirectory, ".gotrue.cache");
    File.WriteAllText(path, JsonSerializer.Serialize(session));
    return true;
}
```

--------------------------------

### IGotrueAdminClient Methods

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

Methods for administrative user management, including deleting, inviting, and updating users, as well as managing MFA factors.

```APIDOC
## IGotrueAdminClient Methods

- **DeleteFactor(MfaAdminDeleteFactorParams deleteFactorParams)**: Deletes an MFA factor for a user.
- **DeleteUser(string uid)**: Deletes a user by their unique ID.
- **GenerateLink(GenerateLinkOptions options)**: Generates a magic link or other authentication link.
- **GetUser(string jwt)**: Retrieves the current user based on a JWT.
- **GetUserById(string userId)**: Retrieves a user by their unique ID.
- **InviteUserByEmail(string email, InviteUserByEmailOptions options)**: Invites a user via email.
- **ListFactors(MfaAdminListFactorsParams listFactorsParams)**: Lists MFA factors for a user.
- **ListUsers(string filter, string sortBy, SortOrder sortOrder, int page, int perPage)**: Lists users with optional filtering and pagination.
- **Update(UserAttributes attributes)**: Updates the current user's attributes.
- **UpdateUserById(string userId, AdminUserAttributes userData)**: Updates a specific user's attributes by ID.
```

--------------------------------

### Perform CRUD Operations

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Postgrest/README.md

Initialize the client and execute read, insert, update, and delete operations on your models.

```csharp
using Supabase.Postgrest;

var client = new Client("http://localhost:3000");

// Read
var response = await client.Table<Message>().Get();
List<Message> messages = response.Models;

// Insert
await client.Table<Message>().Insert(new Message { UserName = "acupofjose", ChannelId = 1 });

// Update (via a fetched model)
var message = response.Models.First();
message.UserName = "elrhomariyounes";
await message.Update<Message>();

// Delete
await response.Models.Last().Delete<Message>();
```

--------------------------------

### Login or Create User with Google Identity Token

Source: https://github.com/supabase-community/supabase-csharp/wiki/Authorization-with-Gotrue

Logs in an existing user or creates a new one using a Google identity token. This method is used after preparing the identity token.

```csharp
var user = await Supabase.Auth.SignInWithIdToken(Supabase.Gotrue.Constants.Provider.Google, identityToken);
```

--------------------------------

### Initialize Gotrue Client with Session Persistence

Source: https://github.com/supabase-community/supabase-csharp/wiki/Authorization-with-Gotrue

This C# code demonstrates how to initialize the Gotrue client with custom session persistence callbacks for MAUI/Xamarin applications. It sets up listeners for debug and state changes, and loads the session.

```csharp
async void Initialize() {

    // Specify the methods you'd like to use as persistence callbacks
    var persistence = new GotrueSessionPersistence(SaveSession, LoadSession, DestroySession);
    var client = new Client(
            Url = GOTRUE_URL,
            new ClientOptions { 
                AllowUnconfirmedUserSessions = true, 
                SessionPersistence = persistence });
                
    // Specify a debug callback to listen to problems with the background token refresh thread
    client.AddDebugListener(LogDebug);
    
    // Specify a call back to listen to changes in the user state (logged in, out, etc)
    client.AddStateChangedListener(AuthStateListener);

    // Load the session from persistence
    client.LoadSession();
    // Loads the session using SessionRetriever and sets state internally.
    await client.RetrieveSessionAsync();
}
```

--------------------------------

### IStorageBucketApi.ListBuckets

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/Storage/PublicAPI.Shipped.txt

Retrieves a list of all storage buckets.

```APIDOC
## ListBuckets()

### Description
Retrieves a list of all buckets available in the storage instance.

### Returns
- **Task<List<TBucket>>** - A task that resolves to a list of bucket objects.
```

--------------------------------

### IRealtimeClient.Channel

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Realtime/Realtime/PublicAPI.Shipped.txt

Creates or retrieves a channel instance from the Realtime client.

```APIDOC
## IRealtimeClient.Channel

### Description
Creates or retrieves a channel by name or by database configuration parameters.

### Signatures
- `TChannel Channel(string channelName)`
- `TChannel Channel(string channelName, ChannelOptions options)`
- `TChannel Channel(string database, string schema, string table, string? column, string? value, Dictionary<string, string>? parameters)`
```

--------------------------------

### Configure OpenTelemetry for Gotrue

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/README.md

Registers the Gotrue ActivitySource and Meter with the OpenTelemetry SDK using the recommended constant.

```csharp
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;
using Supabase.Gotrue;

// Requires OpenTelemetry.Extensions.Hosting and an exporter package (e.g. OTLP) in your app.
builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddSource(GotrueDiagnostics.SourceName)
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddMeter(GotrueDiagnostics.SourceName)
        .AddOtlpExporter());
```

--------------------------------

### AddSupabase(this IServiceCollection, string, string, Action<SupabaseOptions>)

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/extensions/DependencyInjection/DependencyInjection/PublicAPI.Unshipped.txt

Registers the Supabase client in the service collection with the provided URL, key, and optional configuration.

```APIDOC
## AddSupabase

### Description
Registers Supabase services into the provided `IServiceCollection`. This enables the injection of Supabase clients into your application services.

### Signature
`public static IServiceCollection AddSupabase(this IServiceCollection services, string supabaseUrl, string supabaseKey, Action<SupabaseOptions>? configureOptions = null)`

### Parameters
- **services** (IServiceCollection) - Required - The service collection to add the Supabase client to.
- **supabaseUrl** (string) - Required - The URL of your Supabase project.
- **supabaseKey** (string) - Required - The API key for your Supabase project.
- **configureOptions** (Action<SupabaseOptions>) - Optional - An action to configure additional Supabase options.
```

--------------------------------

### Monitor activities with ActivityListener

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Functions/README.md

Use a raw ActivityListener to capture and log client activities if not using the full OpenTelemetry SDK.

```csharp
using System.Diagnostics;
using Supabase.Functions;

using var listener = new ActivityListener
{
    ShouldListenTo = source => source.Name == FunctionsDiagnostics.SourceName,
    Sample = (ref ActivityCreationOptions<ActivityContext> _) => ActivitySamplingResult.AllData,
    ActivityStopped = activity => Console.WriteLine($"{activity.OperationName} {activity.Duration.TotalMilliseconds}ms {activity.Status}")
};
ActivitySource.AddActivityListener(listener);
```

--------------------------------

### Perform File Operations

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/README.md

Interact with files within a bucket to upload, list, move, copy, remove, or download content.

```csharp
var bucket = client.From("avatars");

// Upload from a local path or from bytes.
await bucket.Upload("./local.png", "me.png");
await bucket.Upload(bytes, "me.png");

// List, move, copy, remove.
var files = await bucket.List();
await bucket.Move("me.png", "old/me.png");
await bucket.Copy("old/me.png", "backup/me.png");
await bucket.Remove("old/me.png");

// Download to a local path (returns the path) or into memory (returns bytes).
await bucket.Download("me.png", "./downloaded.png");
byte[] data = await bucket.Download("me.png");
```

--------------------------------

### Manage Storage Buckets

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/README.md

Perform CRUD operations on storage buckets including creation, retrieval, listing, emptying, and deletion.

```csharp
await client.CreateBucket("avatars");

var bucket = await client.GetBucket("avatars");
var all = await client.ListBuckets();

await client.EmptyBucket("avatars");
await client.DeleteBucket("avatars");
```

--------------------------------

### Supabase.Gotrue.AdminClient

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

The AdminClient provides methods for administrative user management, including creating, deleting, and updating users, as well as managing MFA factors.

```APIDOC
## AdminClient Methods

### CreateUser
- `CreateUser(AdminUserAttributes attributes)`: Creates a new user.
- `CreateUser(string email, string password, AdminUserAttributes? attributes)`: Creates a new user with email and password.

### DeleteUser
- `DeleteUser(string uid)`: Deletes a user by their unique identifier.

### GetUser
- `GetUser(string jwt)`: Retrieves a user based on their JWT.
- `GetUserById(string userId)`: Retrieves a user by their unique identifier.

### ListUsers
- `ListUsers(string? filter, string? sortBy, SortOrder sortOrder, int? page, int? perPage)`: Lists users with optional filtering and pagination.

### UpdateUser
- `Update(UserAttributes attributes)`: Updates the current user attributes.
- `UpdateUserById(string userId, AdminUserAttributes userData)`: Updates a specific user by their ID.

### MFA Management
- `ListFactors(MfaAdminListFactorsParams listFactorsParams)`: Lists MFA factors for a user.
- `DeleteFactor(MfaAdminDeleteFactorParams deleteFactorParams)`: Deletes an MFA factor.
```

--------------------------------

### Configure OpenTelemetry for Supabase Storage

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/README.md

Registers the client's ActivitySource and Meter with OpenTelemetry using the StorageDiagnostics.SourceName constant.

```csharp
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;
using Supabase.Storage;

// Requires OpenTelemetry.Extensions.Hosting and an exporter package (e.g. OTLP) in your app.
builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddSource(StorageDiagnostics.SourceName)
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddMeter(StorageDiagnostics.SourceName)
        .AddOtlpExporter());
```

--------------------------------

### IGotrueClient.SignIn

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

Signs a user in using a provider or credentials.

```APIDOC
## SignIn(Provider provider, SignInOptions options)

### Description
Signs a user in using an external identity provider.

### Parameters
- **provider** (Provider) - Required - The identity provider to use.
- **options** (SignInOptions) - Optional - Additional sign-in options.

### Returns
- **Task<ProviderAuthState>** - A task that resolves to the provider authentication state.
```

--------------------------------

### Inject a Supabase sub-client

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/extensions/DependencyInjection/README.md

Resolve specific sub-clients like IPostgrestClient directly in your handlers.

```csharp
app.MapGet("/todos", async (IPostgrestClient postgrest) =>
    await postgrest.Table<Todo>().Get());
```

--------------------------------

### Generate File URLs

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Storage/README.md

Create public URLs for files in public buckets or signed URLs for temporary access to private files.

```csharp
// Public bucket: build a URL directly (pass null for no image transform).
var publicUrl = bucket.GetPublicUrl("me.png", null);

// Private bucket: sign a URL that expires (seconds).
var signedUrl = await bucket.CreateSignedUrl("me.png", 3600);
```

--------------------------------

### Enable offline support

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/README.md

Configures the client to handle network status changes using the NetworkStatus utility.

```csharp
var client = new Client(new ClientOptions { AllowUnconfirmedUserSessions = true });

var status = new NetworkStatus { Client = client };
await status.StartAsync();
```

--------------------------------

### StatelessClient.VerifyOTP (Email)

Source: https://github.com/supabase-community/supabase-csharp/blob/master/packages/Gotrue/Gotrue/PublicAPI.Shipped.txt

Verifies an OTP token sent via email.

```APIDOC
## VerifyOTP (Email)

### Description
Verifies a one-time password (OTP) token sent to an email address.

### Signature
`Task<Session?> VerifyOTP(string email, string otpToken, StatelessClientOptions options, EmailOtpType type = EmailOtpType.MagicLink)`
```
Tokens:
Raw