From 15778ca54f09c63d8a9843168abd46ccfb3b9a96 Mon Sep 17 00:00:00 2001 From: Atharva Deosthale Date: Mon, 27 Apr 2026 23:42:40 +0530 Subject: [PATCH 1/3] feat variables api --- .optimize-cache.json | 2 + src/partials/functions-env-vars.md | 14 + .../announcing-variables-api/+page.markdoc | 1253 ++++++++++++++++ .../changelog/(entries)/2026-04-28.markdoc | 14 + .../docs/advanced/platform/+layout.svelte | 5 + .../environment-variables/+page.markdoc | 1213 +++++++++++++++ .../docs/products/functions/+layout.svelte | 4 + .../products/functions/develop/+page.markdoc | 130 +- .../environment-variables/+page.markdoc | 1307 +++++++++++++++++ .../functions/functions/+page.markdoc | 12 - src/routes/docs/products/sites/+layout.svelte | 4 + .../docs/products/sites/develop/+page.markdoc | 35 - .../sites/environment-variables/+page.markdoc | 1220 +++++++++++++++ .../docs/functions/dark/env-variables.png | Bin 0 -> 104486 bytes .../images/docs/functions/env-variables.png | Bin 0 -> 104812 bytes 15 files changed, 5041 insertions(+), 172 deletions(-) create mode 100644 src/partials/functions-env-vars.md create mode 100644 src/routes/blog/post/announcing-variables-api/+page.markdoc create mode 100644 src/routes/changelog/(entries)/2026-04-28.markdoc create mode 100644 src/routes/docs/advanced/platform/environment-variables/+page.markdoc create mode 100644 src/routes/docs/products/functions/environment-variables/+page.markdoc create mode 100644 src/routes/docs/products/sites/environment-variables/+page.markdoc create mode 100644 static/images/docs/functions/dark/env-variables.png create mode 100644 static/images/docs/functions/env-variables.png diff --git a/.optimize-cache.json b/.optimize-cache.json index 6ef84c3f1a..1e360f4419 100644 --- a/.optimize-cache.json +++ b/.optimize-cache.json @@ -1331,7 +1331,9 @@ "images/docs/databases/scale-policies.png": "549c929932a92902c6a17684730a4bffe0c52ed8dd3d9bebc7ecc7818c81f244", "images/docs/dev-keys/dark.png": "137a92c18e9dfb2c000dea70d7fea09895abe2b46a69bdf8b736997e21c457ba", "images/docs/dev-keys/light.png": "7737135bb6c721adad6761d6c00616d3e9f5a88f153c8481ca55cdf481d63c42", + "images/docs/functions/dark/env-variables.png": "0fe62180f8b3b96f7944c91afcc87dda42cf52d8ce10672608c1df009b048b42", "images/docs/functions/dark/template.png": "4149a261979cb36cf74309d1836a3fcd926f2d33587e92080d541ffcbc3ad19c", + "images/docs/functions/env-variables.png": "003c18ef56a95f0784c9ffd609e313955bd83b61ef277c454bb7dd5b2192280b", "images/docs/functions/execution/dark/execute-function.png": "69063c276041e1e8cea09fb7aa27d3df6727fa6806d15101ac291e1b51f14344", "images/docs/functions/execution/dark/scheduled-execution-function.png": "19fd1f34644186c0113f060c4f4b9c42ecd8392e8a86f32df44f90086943ba33", "images/docs/functions/execution/execute-function.png": "9a5abab51d8c144214ecb6ff13ddd9d60c2cfcc7783aa2946aca5256f4bb83d5", diff --git a/src/partials/functions-env-vars.md b/src/partials/functions-env-vars.md new file mode 100644 index 0000000000..1c5bcde396 --- /dev/null +++ b/src/partials/functions-env-vars.md @@ -0,0 +1,14 @@ +| Variable | Description | Available at Build and/or Run Time | +| ----------------------------------- | ---------------------------------------------------------- | ---------------------------------- | +| `APPWRITE_FUNCTION_API_ENDPOINT` | The API endpoint of the running function | Both | +| `APPWRITE_VERSION` | The Appwrite version used to run the function | Both | +| `APPWRITE_REGION` | The region where the function will run from | Both | +| `APPWRITE_FUNCTION_API_KEY` | The function API key used for server authentication | Build time | +| `APPWRITE_FUNCTION_ID` | The ID of the running function | Both | +| `APPWRITE_FUNCTION_NAME` | The name of the running function | Both | +| `APPWRITE_FUNCTION_DEPLOYMENT` | The deployment ID of the running function | Both | +| `APPWRITE_FUNCTION_PROJECT_ID` | The project ID of the running function | Both | +| `APPWRITE_FUNCTION_RUNTIME_NAME` | The runtime of the running function | Both | +| `APPWRITE_FUNCTION_RUNTIME_VERSION` | The runtime version of the running function | Both | +| `APPWRITE_FUNCTION_CPUS` | The CPU (runtime) specification of the running function | Both | +| `APPWRITE_FUNCTION_MEMORY` | The memory (runtime) specification of the running function | Both | diff --git a/src/routes/blog/post/announcing-variables-api/+page.markdoc b/src/routes/blog/post/announcing-variables-api/+page.markdoc new file mode 100644 index 0000000000..c1630d88ab --- /dev/null +++ b/src/routes/blog/post/announcing-variables-api/+page.markdoc @@ -0,0 +1,1253 @@ +--- +layout: post +title: "Announcing the Variables API: Manage function, site, and project variables from your Server SDKs" +description: Environment variables for functions, sites, and projects can now be created, updated, and deleted programmatically through the Appwrite Server SDKs. Provision configuration as code, rotate secrets in scripts, and bootstrap new environments without touching the Console. +date: 2026-04-28 +cover: /images/blog/announcing-variables-api/cover.png +timeToRead: 4 +author: matej-baco +category: announcement +featured: false +callToAction: true +--- + +Environment variables have always been part of Appwrite. You could set them on a function, on a site, or on the project as a whole, and your code would pick them up at build and runtime. The catch was that all of this lived inside the Appwrite Console. If you wanted to provision configuration as part of a script, rotate a secret across environments, or bootstrap a new project from a template, you had to click through the UI. + +Today, we are announcing the **Variables API**, a unified set of endpoints for managing environment variables on functions, sites, and projects programmatically through the Appwrite Server SDKs. + +This is part of a wider effort to make everything in Appwrite accessible through the API. Anything you can do in the Console should be doable from code, and variables are now a first-class part of that surface. + +# Why this matters + +Configuration drift, manual secret rotation, and click-ops bootstrapping are some of the easiest ways to break a production environment. The Variables API removes them from the loop: + +- **Provision configuration as code** as part of CI/CD, infrastructure scripts, or project templates. +- **Rotate secrets across environments** without opening the Console for each function, site, and project. +- **Bootstrap new projects** with the same baseline of variables every time. +- **Build internal tooling** that lets your team manage shared configuration in one place. +- **Audit and reconcile** what is set against what should be set, programmatically. + +# Three scopes, one API surface + +The Variables API covers all three scopes Appwrite already supported in the Console: + +- **Function variables** live on a single function and are set on the `Functions` service. +- **Site variables** live on a single site and are set on the `Sites` service. +- **Project variables** are shared across every function and site in the project and are set on the `Project` service. + +Each scope exposes the same five operations: create, list, get, update, and delete. At build and runtime, project variables load first, function or site variables override matching keys, and Appwrite-injected variables (those prefixed with `APPWRITE_`) take final precedence. + +# How it works + +The relevant API key scopes are: + +- **`functions.read`** / **`functions.write`** for function variables +- **`sites.read`** / **`sites.write`** for site variables +- **`projects.read`** / **`projects.write`** for project variables + +## Create a project variable + +The new `Project` service exposes `createVariable` for shared configuration: + +{% multicode %} +```server-nodejs +import { Client, Project } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.createVariable({ + variableId: '', + key: 'STRIPE_KEY', + value: 'sk_live_...', + secret: true // optional +}); +``` +```server-deno +import { Client, Project } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.createVariable({ + variableId: '', + key: 'STRIPE_KEY', + value: 'sk_live_...', + secret: true // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$project = new Project($client); + +$result = $project->createVariable( + variableId: '', + key: 'STRIPE_KEY', + value: 'sk_live_...', + secret: true // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.project import Project +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +project = Project(client) + +result: Variable = project.create_variable( + variable_id = '', + key = 'STRIPE_KEY', + value = 'sk_live_...', + secret = True # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +project = Project.new(client) + +result = project.create_variable( + variable_id: '', + key: 'STRIPE_KEY', + value: 'sk_live_...', + secret: true # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Project project = new Project(client); + +Variable result = await project.CreateVariable( + variableId: "", + key: "STRIPE_KEY", + value: "sk_live_...", + secret: true // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Project project = Project(client); + +Variable result = await project.createVariable( + variableId: '', + key: 'STRIPE_KEY', + value: 'sk_live_...', + secret: true, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Project + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val project = Project(client) + +val response = project.createVariable( + variableId = "", + key = "STRIPE_KEY", + value = "sk_live_...", + secret = true // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Project; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Project project = new Project(client); + +project.createVariable( + "", // variableId + "STRIPE_KEY", // key + "sk_live_...", // value + true, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let project = Project(client) + +let variable = try await project.createVariable( + variableId: "", + key: "STRIPE_KEY", + value: "sk_live_...", + secret: true // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +project := appwrite.NewProject(client) + +response, error := project.CreateVariable( + "", + "STRIPE_KEY", + "sk_live_...", + appwrite.WithCreateVariableSecret(true), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Project; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let project = Project::new(&client); + + let result = project.create_variable( + "", + "STRIPE_KEY", + "sk_live_...", + Some(true) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Create a function variable + +The same shape applies on the `Functions` service for variables scoped to a single function: + +{% multicode %} +```server-nodejs +import { Client, Functions } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.createVariable({ + functionId: '', + key: 'OPENAI_API_KEY', + value: 'sk-...', + secret: true // optional +}); +``` +```server-deno +import { Client, Functions } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.createVariable({ + functionId: '', + key: 'OPENAI_API_KEY', + value: 'sk-...', + secret: true // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$functions = new Functions($client); + +$result = $functions->createVariable( + functionId: '', + key: 'OPENAI_API_KEY', + value: 'sk-...', + secret: true // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.functions import Functions +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +functions = Functions(client) + +result: Variable = functions.create_variable( + function_id = '', + key = 'OPENAI_API_KEY', + value = 'sk-...', + secret = True # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +functions = Functions.new(client) + +result = functions.create_variable( + function_id: '', + key: 'OPENAI_API_KEY', + value: 'sk-...', + secret: true # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Functions functions = new Functions(client); + +Variable result = await functions.CreateVariable( + functionId: "", + key: "OPENAI_API_KEY", + value: "sk-...", + secret: true // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Functions functions = Functions(client); + +Variable result = await functions.createVariable( + functionId: '', + key: 'OPENAI_API_KEY', + value: 'sk-...', + secret: true, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Functions + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val functions = Functions(client) + +val response = functions.createVariable( + functionId = "", + key = "OPENAI_API_KEY", + value = "sk-...", + secret = true // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Functions; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Functions functions = new Functions(client); + +functions.createVariable( + "", // functionId + "OPENAI_API_KEY", // key + "sk-...", // value + true, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let functions = Functions(client) + +let variable = try await functions.createVariable( + functionId: "", + key: "OPENAI_API_KEY", + value: "sk-...", + secret: true // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +functions := appwrite.NewFunctions(client) + +response, error := functions.CreateVariable( + "", + "OPENAI_API_KEY", + "sk-...", + appwrite.WithCreateVariableSecret(true), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Functions; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let functions = Functions::new(&client); + + let result = functions.create_variable( + "", + "OPENAI_API_KEY", + "sk-...", + Some(true) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Create a site variable + +And on the `Sites` service for variables scoped to a single site: + +{% multicode %} +```server-nodejs +import { Client, Sites } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.createVariable({ + siteId: '', + key: 'NEXT_PUBLIC_ANALYTICS_ID', + value: 'G-XXXXXXX', + secret: false // optional +}); +``` +```server-deno +import { Client, Sites } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.createVariable({ + siteId: '', + key: 'NEXT_PUBLIC_ANALYTICS_ID', + value: 'G-XXXXXXX', + secret: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$sites = new Sites($client); + +$result = $sites->createVariable( + siteId: '', + key: 'NEXT_PUBLIC_ANALYTICS_ID', + value: 'G-XXXXXXX', + secret: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.sites import Sites +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +sites = Sites(client) + +result: Variable = sites.create_variable( + site_id = '', + key = 'NEXT_PUBLIC_ANALYTICS_ID', + value = 'G-XXXXXXX', + secret = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +sites = Sites.new(client) + +result = sites.create_variable( + site_id: '', + key: 'NEXT_PUBLIC_ANALYTICS_ID', + value: 'G-XXXXXXX', + secret: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Sites sites = new Sites(client); + +Variable result = await sites.CreateVariable( + siteId: "", + key: "NEXT_PUBLIC_ANALYTICS_ID", + value: "G-XXXXXXX", + secret: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Sites sites = Sites(client); + +Variable result = await sites.createVariable( + siteId: '', + key: 'NEXT_PUBLIC_ANALYTICS_ID', + value: 'G-XXXXXXX', + secret: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Sites + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val sites = Sites(client) + +val response = sites.createVariable( + siteId = "", + key = "NEXT_PUBLIC_ANALYTICS_ID", + value = "G-XXXXXXX", + secret = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Sites; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Sites sites = new Sites(client); + +sites.createVariable( + "", // siteId + "NEXT_PUBLIC_ANALYTICS_ID", // key + "G-XXXXXXX", // value + false, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let sites = Sites(client) + +let variable = try await sites.createVariable( + siteId: "", + key: "NEXT_PUBLIC_ANALYTICS_ID", + value: "G-XXXXXXX", + secret: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +sites := appwrite.NewSites(client) + +response, error := sites.CreateVariable( + "", + "NEXT_PUBLIC_ANALYTICS_ID", + "G-XXXXXXX", + appwrite.WithCreateVariableSecret(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Sites; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let sites = Sites::new(&client); + + let result = sites.create_variable( + "", + "NEXT_PUBLIC_ANALYTICS_ID", + "G-XXXXXXX", + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Update a project variable + +`updateVariable` exists on all three services with the same shape. Updating a variable lets you rotate a value or change its secret flag without recreating it. Marking a variable as secret cannot be reversed. To replace a secret value, delete the variable and create a new one with the same key. + +{% multicode %} +```server-nodejs +import { Client, Project } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.updateVariable({ + variableId: '', + key: 'STRIPE_KEY', // optional + value: 'sk_live_rotated_...', // optional + secret: false // optional +}); +``` +```server-deno +import { Client, Project } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.updateVariable({ + variableId: '', + key: 'STRIPE_KEY', // optional + value: 'sk_live_rotated_...', // optional + secret: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$project = new Project($client); + +$result = $project->updateVariable( + variableId: '', + key: 'STRIPE_KEY', // optional + value: 'sk_live_rotated_...', // optional + secret: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.project import Project +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +project = Project(client) + +result: Variable = project.update_variable( + variable_id = '', + key = 'STRIPE_KEY', # optional + value = 'sk_live_rotated_...', # optional + secret = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +project = Project.new(client) + +result = project.update_variable( + variable_id: '', + key: 'STRIPE_KEY', # optional + value: 'sk_live_rotated_...', # optional + secret: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Project project = new Project(client); + +Variable result = await project.UpdateVariable( + variableId: "", + key: "STRIPE_KEY", // optional + value: "sk_live_rotated_...", // optional + secret: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Project project = Project(client); + +Variable result = await project.updateVariable( + variableId: '', + key: 'STRIPE_KEY', // (optional) + value: 'sk_live_rotated_...', // (optional) + secret: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Project + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val project = Project(client) + +val response = project.updateVariable( + variableId = "", + key = "STRIPE_KEY", // optional + value = "sk_live_rotated_...", // optional + secret = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Project; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Project project = new Project(client); + +project.updateVariable( + "", // variableId + "STRIPE_KEY", // key (optional) + "sk_live_rotated_...", // value (optional) + false, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let project = Project(client) + +let variable = try await project.updateVariable( + variableId: "", + key: "STRIPE_KEY", // optional + value: "sk_live_rotated_...", // optional + secret: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +project := appwrite.NewProject(client) + +response, error := project.UpdateVariable( + "", + appwrite.WithUpdateVariableKey("STRIPE_KEY"), + appwrite.WithUpdateVariableValue("sk_live_rotated_..."), + appwrite.WithUpdateVariableSecret(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Project; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let project = Project::new(&client); + + let result = project.update_variable( + "", + Some("STRIPE_KEY"), // optional + Some("sk_live_rotated_..."), // optional + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Delete a project variable + +`deleteVariable` is available on each service. Once deleted, the variable stops appearing in subsequent function and site deployments. + +{% multicode %} +```server-nodejs +import { Client, Project } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.deleteVariable({ + variableId: '' +}); +``` +```server-deno +import { Client, Project } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.deleteVariable({ + variableId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$project = new Project($client); + +$result = $project->deleteVariable( + variableId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.project import Project + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +project = Project(client) + +result = project.delete_variable( + variable_id = '' +) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +project = Project.new(client) + +result = project.delete_variable( + variable_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Project project = new Project(client); + +await project.DeleteVariable( + variableId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Project project = Project(client); + +await project.deleteVariable( + variableId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Project + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val project = Project(client) + +val response = project.deleteVariable( + variableId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Project; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Project project = new Project(client); + +project.deleteVariable( + "", // variableId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let project = Project(client) + +let result = try await project.deleteVariable( + variableId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +project := appwrite.NewProject(client) + +response, error := project.DeleteVariable( + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Project; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let project = Project::new(&client); + + project.delete_variable( + "" + ).await?; + + Ok(()) +} +``` +{% /multicode %} + +# Get started + +The Variables API is available on **Appwrite Cloud** today, across every Appwrite Server SDK. Complete code examples for every supported language and every operation live in the documentation: + +- [Project variables](/docs/advanced/platform/environment-variables) +- [Function variables](/docs/products/functions/environment-variables) +- [Site variables](/docs/products/sites/environment-variables) diff --git a/src/routes/changelog/(entries)/2026-04-28.markdoc b/src/routes/changelog/(entries)/2026-04-28.markdoc new file mode 100644 index 0000000000..f0715386e4 --- /dev/null +++ b/src/routes/changelog/(entries)/2026-04-28.markdoc @@ -0,0 +1,14 @@ +--- +layout: changelog +title: "Variables API: manage function, site, and project variables with Server SDKs" +date: 2026-04-28 +cover: /images/blog/announcing-variables-api/cover.png +--- + +Environment variables for functions, sites, and projects can now be created, listed, retrieved, updated, and deleted programmatically through the Appwrite Server SDKs. Two new API key scopes, `project.read` and `project.write`, control access to the project-scoped endpoints, alongside the existing `functions.*` and `sites.*` scopes for resource-scoped variables. + +This enables configuration as code, one-place rotation of secrets shared across multiple resources, and repeatable bootstraps of new environments and tenants from scripts or templates. + +{% arrow_link href="/blog/post/announcing-variables-api" %} +Read the announcement +{% /arrow_link %} diff --git a/src/routes/docs/advanced/platform/+layout.svelte b/src/routes/docs/advanced/platform/+layout.svelte index 5e1739b622..219c63c770 100644 --- a/src/routes/docs/advanced/platform/+layout.svelte +++ b/src/routes/docs/advanced/platform/+layout.svelte @@ -126,6 +126,11 @@ label: 'Custom domains', href: '/docs/advanced/platform/custom-domains' }, + { + label: 'Environment variables', + new: isNewUntil('30 May 2026'), + href: '/docs/advanced/platform/environment-variables' + }, { label: 'Message templates', href: '/docs/advanced/platform/message-templates' diff --git a/src/routes/docs/advanced/platform/environment-variables/+page.markdoc b/src/routes/docs/advanced/platform/environment-variables/+page.markdoc new file mode 100644 index 0000000000..c7bca06393 --- /dev/null +++ b/src/routes/docs/advanced/platform/environment-variables/+page.markdoc @@ -0,0 +1,1213 @@ +--- +layout: article +title: Environment variables +description: Use project, function, and site environment variables to pass constants and secrets to your Appwrite Functions and Appwrite Sites at build and runtime. +--- + +Environment variables let you pass constants and secrets such as API keys, connection strings, and feature flags into your Appwrite Functions and Appwrite Sites at build and runtime. Storing values outside your source keeps secrets out of version control and lets you change configuration without code changes. + +Appwrite supports three scopes of environment variables: + +- **Project variables** are shared across every function and site in the project. Use them for values consumed by more than one resource, such as a shared third-party API key, a database URL, or a feature flag. +- **Function variables** are scoped to a single function. Use them for values only that function needs. +- **Site variables** are scoped to a single site. Use them for values only that site needs. + +When the same key is defined in multiple scopes, the more specific scope wins. Function or site variables override project variables, and Appwrite-injected variables (those prefixed with `APPWRITE_`) take final precedence and cannot be overridden. + +{% info title="Redeployment required" %} +Variable changes only take effect on the next deployment. Redeploy your functions or sites after creating, updating, or deleting variables. +{% /info %} + +# Project variables {% #project-variables %} + +Project variables are available to every function and site in your project. They are managed at the project level and merged into each function or site's environment automatically at build and runtime. + +This page covers how to manage project variables. To manage variables on a single function or site, see the dedicated pages: + +{% cards %} +{% cards_item href="/docs/products/functions/environment-variables" title="Function variables" %} +Manage variables for a single function. +{% /cards_item %} +{% cards_item href="/docs/products/sites/environment-variables" title="Site variables" %} +Manage variables for a single site. +{% /cards_item %} +{% /cards %} + +# Manage in the Console {% #console %} + +You can create and manage project variables from the Appwrite Console: + +1. Navigate to your project. +2. Open **Settings** > **Environment variables**. +3. Click **Create variable** and enter a key and value. +4. Optionally select the **Secret** checkbox to prevent any team member from reading the value after creation. +5. Click **Create**, then redeploy your functions and sites for the change to take effect. + +{% only_dark %} +![Project environment variables](/images/docs/sites/dark/env-variables.png) +{% /only_dark %} +{% only_light %} +![Project environment variables](/images/docs/sites/env-variables.png) +{% /only_light %} + +# Manage with a Server SDK {% #server-sdks %} + +You can also manage project variables programmatically using a [Server SDK](/docs/sdks#server). Each call requires an [API key](/docs/advanced/platform/api-keys) with the `projects.write` scope to create, update, or delete variables, or the `projects.read` scope to list and read them. + +## Create a variable {% #create-variable %} + +{% multicode %} +```server-nodejs +import { Client, Project } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.createVariable({ + variableId: '', + key: '', + value: '', + secret: false // optional +}); +``` +```server-deno +import { Client, Project } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.createVariable({ + variableId: '', + key: '', + value: '', + secret: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$project = new Project($client); + +$result = $project->createVariable( + variableId: '', + key: '', + value: '', + secret: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.project import Project +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +project = Project(client) + +result: Variable = project.create_variable( + variable_id = '', + key = '', + value = '', + secret = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +project = Project.new(client) + +result = project.create_variable( + variable_id: '', + key: '', + value: '', + secret: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Project project = new Project(client); + +Variable result = await project.CreateVariable( + variableId: "", + key: "", + value: "", + secret: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Project project = Project(client); + +Variable result = await project.createVariable( + variableId: '', + key: '', + value: '', + secret: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Project + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val project = Project(client) + +val response = project.createVariable( + variableId = "", + key = "", + value = "", + secret = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Project; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Project project = new Project(client); + +project.createVariable( + "", // variableId + "", // key + "", // value + false, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let project = Project(client) + +let variable = try await project.createVariable( + variableId: "", + key: "", + value: "", + secret: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +project := appwrite.NewProject(client) + +response, error := project.CreateVariable( + "", + "", + "", + appwrite.WithCreateVariableSecret(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Project; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let project = Project::new(&client); + + let result = project.create_variable( + "", + "", + "", + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## List variables {% #list-variables %} + +You can paginate, filter, and sort the result. See [Queries](/docs/products/databases/queries) for the query syntax. The list endpoint accepts queries on the `key`, `value`, and `secret` attributes. + +{% multicode %} +```server-nodejs +import { Client, Project } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.listVariables({ + queries: [], // optional + total: false // optional +}); +``` +```server-deno +import { Client, Project } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.listVariables({ + queries: [], // optional + total: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$project = new Project($client); + +$result = $project->listVariables( + queries: [], // optional + total: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.project import Project +from appwrite.models import VariableList + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +project = Project(client) + +result: VariableList = project.list_variables( + queries = [], # optional + total = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +project = Project.new(client) + +result = project.list_variables( + queries: [], # optional + total: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Project project = new Project(client); + +VariableList result = await project.ListVariables( + queries: new List(), // optional + total: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Project project = Project(client); + +VariableList result = await project.listVariables( + queries: [], // (optional) + total: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Project + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val project = Project(client) + +val response = project.listVariables( + queries = listOf(), // optional + total = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Project; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Project project = new Project(client); + +project.listVariables( + List.of(), // queries (optional) + false, // total (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let project = Project(client) + +let variableList = try await project.listVariables( + queries: [], // optional + total: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +project := appwrite.NewProject(client) + +response, error := project.ListVariables( + appwrite.WithListVariablesQueries([]interface{}{}), + appwrite.WithListVariablesTotal(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Project; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let project = Project::new(&client); + + let result = project.list_variables( + Some(vec![]), // optional + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Get a variable {% #get-variable %} + +{% multicode %} +```server-nodejs +import { Client, Project } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.getVariable({ + variableId: '' +}); +``` +```server-deno +import { Client, Project } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.getVariable({ + variableId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$project = new Project($client); + +$result = $project->getVariable( + variableId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.project import Project +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +project = Project(client) + +result: Variable = project.get_variable( + variable_id = '' +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +project = Project.new(client) + +result = project.get_variable( + variable_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Project project = new Project(client); + +Variable result = await project.GetVariable( + variableId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Project project = Project(client); + +Variable result = await project.getVariable( + variableId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Project + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val project = Project(client) + +val response = project.getVariable( + variableId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Project; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Project project = new Project(client); + +project.getVariable( + "", // variableId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let project = Project(client) + +let variable = try await project.getVariable( + variableId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +project := appwrite.NewProject(client) + +response, error := project.GetVariable( + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Project; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let project = Project::new(&client); + + let result = project.get_variable( + "" + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Update a variable {% #update-variable %} + +You can change a variable's `key`, `value`, or `secret` flag. Marking a variable as secret is one-way. Once set, the value is no longer readable from the Console or API. + +{% multicode %} +```server-nodejs +import { Client, Project } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.updateVariable({ + variableId: '', + key: '', // optional + value: '', // optional + secret: false // optional +}); +``` +```server-deno +import { Client, Project } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.updateVariable({ + variableId: '', + key: '', // optional + value: '', // optional + secret: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$project = new Project($client); + +$result = $project->updateVariable( + variableId: '', + key: '', // optional + value: '', // optional + secret: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.project import Project +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +project = Project(client) + +result: Variable = project.update_variable( + variable_id = '', + key = '', # optional + value = '', # optional + secret = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +project = Project.new(client) + +result = project.update_variable( + variable_id: '', + key: '', # optional + value: '', # optional + secret: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Project project = new Project(client); + +Variable result = await project.UpdateVariable( + variableId: "", + key: "", // optional + value: "", // optional + secret: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Project project = Project(client); + +Variable result = await project.updateVariable( + variableId: '', + key: '', // (optional) + value: '', // (optional) + secret: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Project + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val project = Project(client) + +val response = project.updateVariable( + variableId = "", + key = "", // optional + value = "", // optional + secret = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Project; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Project project = new Project(client); + +project.updateVariable( + "", // variableId + "", // key (optional) + "", // value (optional) + false, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let project = Project(client) + +let variable = try await project.updateVariable( + variableId: "", + key: "", // optional + value: "", // optional + secret: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +project := appwrite.NewProject(client) + +response, error := project.UpdateVariable( + "", + appwrite.WithUpdateVariableKey(""), + appwrite.WithUpdateVariableValue(""), + appwrite.WithUpdateVariableSecret(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Project; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let project = Project::new(&client); + + let result = project.update_variable( + "", + Some(""), // optional + Some(""), // optional + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Delete a variable {% #delete-variable %} + +{% multicode %} +```server-nodejs +import { Client, Project } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.deleteVariable({ + variableId: '' +}); +``` +```server-deno +import { Client, Project } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const project = new Project(client); + +const result = await project.deleteVariable({ + variableId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$project = new Project($client); + +$result = $project->deleteVariable( + variableId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.project import Project + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +project = Project(client) + +result = project.delete_variable( + variable_id = '' +) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +project = Project.new(client) + +result = project.delete_variable( + variable_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Project project = new Project(client); + +await project.DeleteVariable( + variableId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Project project = Project(client); + +await project.deleteVariable( + variableId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Project + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val project = Project(client) + +val response = project.deleteVariable( + variableId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Project; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Project project = new Project(client); + +project.deleteVariable( + "", // variableId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let project = Project(client) + +let result = try await project.deleteVariable( + variableId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +project := appwrite.NewProject(client) + +response, error := project.DeleteVariable( + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Project; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let project = Project::new(&client); + + project.delete_variable( + "" + ).await?; + + Ok(()) +} +``` +{% /multicode %} + +# Secret variables {% #secret-variables %} + +Mark a variable as **Secret** to hide its value from the Console and API after creation. Only the function or site runtime can read the value at build and runtime. Team members and external integrations cannot retrieve it after creation. + +You can mark a variable as secret either when you create it or by updating an existing variable. Marking a variable as secret cannot be reversed. To replace a secret value, delete the variable and create a new one with the same key. + +# Override behavior {% #overrides %} + +When the same key is defined in multiple scopes, more specific scopes take precedence: + +1. Project variables are merged into the runtime environment first. +2. Function or site variables override matching keys from project scope. +3. Appwrite-injected variables (those prefixed with `APPWRITE_`) override matching keys from both scopes and cannot be customized. + +This lets you set a default at the project level (for example, `LOG_LEVEL=info`) and override it for a specific function or site that needs different behavior. + +# Limits {% #limits %} + +| Field | Limit | +|----------------|------------------------------------------------| +| Variable ID | 36 characters, `a-z A-Z 0-9 . - _` | +| Key | 255 characters | +| Value | 8192 characters | +| Reserved keys | Any key starting with `APPWRITE_` is reserved | diff --git a/src/routes/docs/products/functions/+layout.svelte b/src/routes/docs/products/functions/+layout.svelte index 0dcc198176..a6ae8dfcee 100644 --- a/src/routes/docs/products/functions/+layout.svelte +++ b/src/routes/docs/products/functions/+layout.svelte @@ -40,6 +40,10 @@ label: 'Domains', href: '/docs/products/functions/domains' }, + { + label: 'Environment variables', + href: '/docs/products/functions/environment-variables' + }, { label: 'Runtimes', href: '/docs/products/functions/runtimes' diff --git a/src/routes/docs/products/functions/develop/+page.markdoc b/src/routes/docs/products/functions/develop/+page.markdoc index 348f99b288..455497ee57 100644 --- a/src/routes/docs/products/functions/develop/+page.markdoc +++ b/src/routes/docs/products/functions/develop/+page.markdoc @@ -1318,133 +1318,13 @@ You can access these logs through the following steps. 3. Under the Executions tab, click on an execution. 4. In the Response section, you'll be able to view logs under the Logs and Errors tabs. -# Accessing environment variables {% #environment-variables %} -If you need to pass constants or secrets to Appwrite Functions, you can use environment variables. - -| Variable | Description | Available at Build and/or Run Time | -|-----------------------------------|------------------------------------------------|-----------------------------------------------------| -| `APPWRITE_FUNCTION_API_ENDPOINT` | The API endpoint of the running function | Both | -| `APPWRITE_VERSION` | The Appwrite version used to run the function | Both | -| `APPWRITE_REGION` | The region where the function will run from | Both | -| `APPWRITE_FUNCTION_API_KEY` | The function API key is used for server authentication | Build time | -| `APPWRITE_FUNCTION_ID` | The ID of the running function. | Both | -| `APPWRITE_FUNCTION_NAME` | The Name of the running function. | Both | -| `APPWRITE_FUNCTION_DEPLOYMENT` | The deployment ID of the running function. | Both | -| `APPWRITE_FUNCTION_PROJECT_ID` | The project ID of the running function. | Both | -| `APPWRITE_FUNCTION_RUNTIME_NAME` | The runtime of the running function. | Both | -| `APPWRITE_FUNCTION_RUNTIME_VERSION` | The runtime version of the running function. | Both | - -{% arrow_link href="/docs/products/functions/functions#environment-variables" %} -Learn to add variables to you function -{% /arrow_link %} - -You can access the environment variables through the systems library of each language. - -{% multicode %} -```server-nodejs -export default async ({ req, res, log }) => { - return res.text(process.env.MY_VAR); -} -``` -```php -res->text(getenv('MY_VAR')); -}; -``` -```python -def main(context): - return context.res.text(os.environ['MY_VAR']) -``` -```ruby -def main(context) - return context.res.text(ENV['MY_VAR']) -end -``` -```deno -export default async ({ req, res, log }) => { - return res.text(Deno.env.get('MY_VAR')); -} -``` -```go -package handler - -import ( - "os" +# Environment variables {% #environment-variables %} - "github.com/open-runtimes/types-for-go/v4/openruntimes" -) +Pass constants and secrets into your function with environment variables, and read them inside your function using your runtime's standard environment lookup. -func Main(Context openruntimes.Context) openruntimes.Response { - return res.text(os.Getenv(MY_VAR)) -} -``` -```dart -import 'dart:io'; -import 'dart:async'; - -Future main(final context) async { - return context.res.text(Platform.environment['MY_VAR']); -} -``` -```swift -import Foundation - -func main(context: RuntimeContext) async throws -> RuntimeOutput { - return context.res.text(ProcessInfo.processInfo.environment["MY_VAR"]) -} -``` -```csharp -namespace DotNetRuntime; - -public class Handler { - public async Task Main(RuntimeContext Context) - { - return Context.Res.Text(Environment.GetEnvironmentVariable("MY_VAR")); - } -} -``` -```kotlin -package io.openruntimes.kotlin.src - -import io.openruntimes.kotlin.RuntimeContext -import io.openruntimes.kotlin.RuntimeOutput - -class Main { - fun main(context: RuntimeContext): RuntimeOutput { - return context.res.text(System.getenv("MY_VAR")) - } -} -``` -```java -package io.openruntimes.java.src; - -import io.openruntimes.java.RuntimeContext; -import io.openruntimes.java.RuntimeOutput; - -public class Main { - public RuntimeOutput main(RuntimeContext context) throws Exception { - return context.getRes().text(System.getenv("MY_VAR")); - } -} -``` -```cpp -#include "../RuntimeResponse.h" -#include "../RuntimeRequest.h" -#include "../RuntimeOutput.h" -#include "../RuntimeContext.h" - -namespace runtime { - class Handler { - public: - static RuntimeOutput main(RuntimeContext &context) { - return context.res.text(std::getenv("MY_VAR")); - } - }; -} -``` -{% /multicode %} +{% arrow_link href="/docs/products/functions/environment-variables" %} +Manage and read environment variables +{% /arrow_link %} # Dependencies {% #dependencies %} To install your dependencies before your function is built, diff --git a/src/routes/docs/products/functions/environment-variables/+page.markdoc b/src/routes/docs/products/functions/environment-variables/+page.markdoc new file mode 100644 index 0000000000..3e97d41546 --- /dev/null +++ b/src/routes/docs/products/functions/environment-variables/+page.markdoc @@ -0,0 +1,1307 @@ +--- +layout: article +title: Environment variables +description: Set environment variables for your Appwrite Functions to pass constants and secrets at build and runtime. +--- + +Appwrite Functions can read environment variables at build and runtime. Use them to pass constants and secrets such as API keys, connection strings, and feature flags without hardcoding them in your source. + +A function reads from three sources, in this order of precedence: + +1. **Project variables** are shared across every function and site in your project. Set them once and every function inherits them automatically. See [project variables](/docs/advanced/platform/environment-variables) for the platform-wide reference. +2. **Function variables** are scoped to a single function. Override a project variable for one function by setting the same key on the function itself. +3. **Appwrite-injected variables** are set by Appwrite at execution time (for example, `APPWRITE_FUNCTION_PROJECT_ID`). These take final precedence and cannot be overridden. + +{% info title="Redeployment required" %} +Variable changes only take effect on the next deployment. Redeploy your function after creating, updating, or deleting variables. +{% /info %} + +# Manage in the Console {% #console %} + +1. Navigate to your function in the Appwrite Console. +2. Open the **Settings** tab > **Environment variables** section. +3. Click **Create variable** and enter a key and value. +4. Optionally select the **Secret** checkbox to prevent any team member from reading the value after creation. +5. Click **Create**, then redeploy the function for the change to take effect. + +{% only_dark %} +![Function environment variables](/images/docs/functions/dark/env-variables.png) +{% /only_dark %} +{% only_light %} +![Function environment variables](/images/docs/functions/env-variables.png) +{% /only_light %} + +You can also configure global variables that apply to all your functions from your project's **Settings** page. See [project variables](/docs/advanced/platform/environment-variables) for details. + +# Manage with a Server SDK {% #server-sdks %} + +You can also manage function variables programmatically using a [Server SDK](/docs/sdks#server). Each call requires an [API key](/docs/advanced/platform/api-keys) with the `functions.write` scope to create, update, or delete variables, or the `functions.read` scope to list and read them. + +## Create a variable {% #create-variable %} + +{% multicode %} +```server-nodejs +import { Client, Functions } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.createVariable({ + functionId: '', + key: '', + value: '', + secret: false // optional +}); +``` +```server-deno +import { Client, Functions } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.createVariable({ + functionId: '', + key: '', + value: '', + secret: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$functions = new Functions($client); + +$result = $functions->createVariable( + functionId: '', + key: '', + value: '', + secret: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.functions import Functions +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +functions = Functions(client) + +result: Variable = functions.create_variable( + function_id = '', + key = '', + value = '', + secret = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +functions = Functions.new(client) + +result = functions.create_variable( + function_id: '', + key: '', + value: '', + secret: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Functions functions = new Functions(client); + +Variable result = await functions.CreateVariable( + functionId: "", + key: "", + value: "", + secret: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Functions functions = Functions(client); + +Variable result = await functions.createVariable( + functionId: '', + key: '', + value: '', + secret: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Functions + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val functions = Functions(client) + +val response = functions.createVariable( + functionId = "", + key = "", + value = "", + secret = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Functions; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Functions functions = new Functions(client); + +functions.createVariable( + "", // functionId + "", // key + "", // value + false, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let functions = Functions(client) + +let variable = try await functions.createVariable( + functionId: "", + key: "", + value: "", + secret: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +functions := appwrite.NewFunctions(client) + +response, error := functions.CreateVariable( + "", + "", + "", + appwrite.WithCreateVariableSecret(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Functions; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let functions = Functions::new(&client); + + let result = functions.create_variable( + "", + "", + "", + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## List variables {% #list-variables %} + +{% multicode %} +```server-nodejs +import { Client, Functions } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.listVariables({ + functionId: '' +}); +``` +```server-deno +import { Client, Functions } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.listVariables({ + functionId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$functions = new Functions($client); + +$result = $functions->listVariables( + functionId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.functions import Functions +from appwrite.models import VariableList + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +functions = Functions(client) + +result: VariableList = functions.list_variables( + function_id = '' +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +functions = Functions.new(client) + +result = functions.list_variables( + function_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Functions functions = new Functions(client); + +VariableList result = await functions.ListVariables( + functionId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Functions functions = Functions(client); + +VariableList result = await functions.listVariables( + functionId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Functions + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val functions = Functions(client) + +val response = functions.listVariables( + functionId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Functions; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Functions functions = new Functions(client); + +functions.listVariables( + "", // functionId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let functions = Functions(client) + +let variableList = try await functions.listVariables( + functionId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +functions := appwrite.NewFunctions(client) + +response, error := functions.ListVariables( + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Functions; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let functions = Functions::new(&client); + + let result = functions.list_variables( + "" + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Get a variable {% #get-variable %} + +{% multicode %} +```server-nodejs +import { Client, Functions } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.getVariable({ + functionId: '', + variableId: '' +}); +``` +```server-deno +import { Client, Functions } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.getVariable({ + functionId: '', + variableId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$functions = new Functions($client); + +$result = $functions->getVariable( + functionId: '', + variableId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.functions import Functions +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +functions = Functions(client) + +result: Variable = functions.get_variable( + function_id = '', + variable_id = '' +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +functions = Functions.new(client) + +result = functions.get_variable( + function_id: '', + variable_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Functions functions = new Functions(client); + +Variable result = await functions.GetVariable( + functionId: "", + variableId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Functions functions = Functions(client); + +Variable result = await functions.getVariable( + functionId: '', + variableId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Functions + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val functions = Functions(client) + +val response = functions.getVariable( + functionId = "", + variableId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Functions; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Functions functions = new Functions(client); + +functions.getVariable( + "", // functionId + "", // variableId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let functions = Functions(client) + +let variable = try await functions.getVariable( + functionId: "", + variableId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +functions := appwrite.NewFunctions(client) + +response, error := functions.GetVariable( + "", + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Functions; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let functions = Functions::new(&client); + + let result = functions.get_variable( + "", + "" + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Update a variable {% #update-variable %} + +You can change a variable's `key`, `value`, or `secret` flag. Marking a variable as secret is one-way. Once set, the value is no longer readable from the Console or API. + +{% multicode %} +```server-nodejs +import { Client, Functions } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.updateVariable({ + functionId: '', + variableId: '', + key: '', + value: '', // optional + secret: false // optional +}); +``` +```server-deno +import { Client, Functions } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.updateVariable({ + functionId: '', + variableId: '', + key: '', + value: '', // optional + secret: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$functions = new Functions($client); + +$result = $functions->updateVariable( + functionId: '', + variableId: '', + key: '', + value: '', // optional + secret: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.functions import Functions +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +functions = Functions(client) + +result: Variable = functions.update_variable( + function_id = '', + variable_id = '', + key = '', + value = '', # optional + secret = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +functions = Functions.new(client) + +result = functions.update_variable( + function_id: '', + variable_id: '', + key: '', + value: '', # optional + secret: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Functions functions = new Functions(client); + +Variable result = await functions.UpdateVariable( + functionId: "", + variableId: "", + key: "", + value: "", // optional + secret: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Functions functions = Functions(client); + +Variable result = await functions.updateVariable( + functionId: '', + variableId: '', + key: '', + value: '', // (optional) + secret: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Functions + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val functions = Functions(client) + +val response = functions.updateVariable( + functionId = "", + variableId = "", + key = "", + value = "", // optional + secret = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Functions; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Functions functions = new Functions(client); + +functions.updateVariable( + "", // functionId + "", // variableId + "", // key + "", // value (optional) + false, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let functions = Functions(client) + +let variable = try await functions.updateVariable( + functionId: "", + variableId: "", + key: "", + value: "", // optional + secret: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +functions := appwrite.NewFunctions(client) + +response, error := functions.UpdateVariable( + "", + "", + "", + appwrite.WithUpdateVariableValue(""), + appwrite.WithUpdateVariableSecret(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Functions; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let functions = Functions::new(&client); + + let result = functions.update_variable( + "", + "", + "", + Some(""), // optional + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Delete a variable {% #delete-variable %} + +{% multicode %} +```server-nodejs +import { Client, Functions } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.deleteVariable({ + functionId: '', + variableId: '' +}); +``` +```server-deno +import { Client, Functions } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const functions = new Functions(client); + +const result = await functions.deleteVariable({ + functionId: '', + variableId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$functions = new Functions($client); + +$result = $functions->deleteVariable( + functionId: '', + variableId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.functions import Functions + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +functions = Functions(client) + +result = functions.delete_variable( + function_id = '', + variable_id = '' +) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +functions = Functions.new(client) + +result = functions.delete_variable( + function_id: '', + variable_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Functions functions = new Functions(client); + +await functions.DeleteVariable( + functionId: "", + variableId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Functions functions = Functions(client); + +await functions.deleteVariable( + functionId: '', + variableId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Functions + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val functions = Functions(client) + +val response = functions.deleteVariable( + functionId = "", + variableId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Functions; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Functions functions = new Functions(client); + +functions.deleteVariable( + "", // functionId + "", // variableId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let functions = Functions(client) + +let result = try await functions.deleteVariable( + functionId: "", + variableId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +functions := appwrite.NewFunctions(client) + +response, error := functions.DeleteVariable( + "", + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Functions; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let functions = Functions::new(&client); + + functions.delete_variable( + "", + "" + ).await?; + + Ok(()) +} +``` +{% /multicode %} + +# Read variables in your function {% #read-variables %} + +Once a variable is set, you can read it inside your function using your runtime language's standard environment lookup. + +{% multicode %} +```server-nodejs +export default async ({ req, res, log }) => { + return res.text(process.env.MY_VAR); +} +``` +```server-deno +export default async ({ req, res, log }) => { + return res.text(Deno.env.get('MY_VAR')); +} +``` +```server-php +res->text(getenv('MY_VAR')); +}; +``` +```server-python +def main(context): + return context.res.text(os.environ['MY_VAR']) +``` +```server-ruby +def main(context) + return context.res.text(ENV['MY_VAR']) +end +``` +```server-dotnet +namespace DotNetRuntime; + +public class Handler { + public async Task Main(RuntimeContext Context) { + var myVar = Environment.GetEnvironmentVariable("MY_VAR"); + return Context.Res.Text(myVar); + } +} +``` +```server-dart +import 'dart:io'; +import 'dart:async'; + +Future main(final context) async { + return context.res.text(Platform.environment['MY_VAR']); +} +``` +```server-kotlin +import io.openruntimes.kotlin.RuntimeContext +import io.openruntimes.kotlin.RuntimeOutput + +class Handler { + suspend fun main(context: RuntimeContext): RuntimeOutput { + return context.res.text(System.getenv("MY_VAR")) + } +} +``` +```server-java +import io.openruntimes.java.RuntimeContext; +import io.openruntimes.java.RuntimeOutput; + +public class Handler { + public RuntimeOutput main(RuntimeContext context) throws Exception { + return context.res.text(System.getenv("MY_VAR")); + } +} +``` +```server-swift +import Foundation + +func main(context: RuntimeContext) async throws -> RuntimeOutput { + return context.res.text(ProcessInfo.processInfo.environment["MY_VAR"] ?? "") +} +``` +```server-go +package handler + +import ( + "os" + + "github.com/open-runtimes/types-for-go/v4/openruntimes" +) + +func Main(Context openruntimes.Context) openruntimes.Response { + return Context.Res.Text(os.Getenv("MY_VAR")) +} +``` +{% /multicode %} + +# Appwrite-injected variables {% #appwrite-variables %} + +Appwrite passes the following environment variables into every function deployment by default. They take precedence over your own variables, so do not set keys with the `APPWRITE_` prefix. + +{% partial file="functions-env-vars.md" /%} + +During the build process, dynamic API keys are automatically provided as the environment variable `APPWRITE_FUNCTION_API_KEY`. This environment variable does not need to be initialized. + +# Secret variables {% #secret-variables %} + +Mark a variable as **Secret** to hide its value from the Console and API after creation. Only the function runtime can read the value at build and runtime. Team members and external integrations cannot retrieve it after creation. + +You can mark a variable as secret either when you create it or by updating an existing variable. Marking a variable as secret cannot be reversed. To replace a secret value, delete the variable and create a new one with the same key. + +# Limits {% #limits %} + +| Field | Limit | +|----------------|------------------------------------------------| +| Variable ID | 36 characters, `a-z A-Z 0-9 . - _` | +| Key | 255 characters | +| Value | 8192 characters | +| Reserved keys | Any key starting with `APPWRITE_` is reserved | diff --git a/src/routes/docs/products/functions/functions/+page.markdoc b/src/routes/docs/products/functions/functions/+page.markdoc index 0fd108ab7e..13995ab960 100644 --- a/src/routes/docs/products/functions/functions/+page.markdoc +++ b/src/routes/docs/products/functions/functions/+page.markdoc @@ -160,18 +160,6 @@ Here are some cron expressions for common intervals: | `0 0 * * *` | Every day at 00:00 | | `0 0 * * 1` | Every Monday at 00:00 | -## Environment variables {% #environment-variables %} -Set static environment variables that will be passed to your function -by navigating to your function > **Settings** > **Environment variables**. - -You can also configure global variables that apply to all your functions in the **Settings** of your project. - -{% info title="Redeployment required" %} -This change requires your function to be redeployed to take effect. -{% /info %} - -You can access environment variables inside functions using your [runtime language's system methods](/docs/products/functions/develop#environment-variables). - ## Timeout {% #timeout %} You can limit the execution time of your function by navigating to your function > **Settings** > **Timeout**. There is a system wide maximum timeout of 900 seconds (15 minutes). diff --git a/src/routes/docs/products/sites/+layout.svelte b/src/routes/docs/products/sites/+layout.svelte index 872e412b84..36454587f7 100644 --- a/src/routes/docs/products/sites/+layout.svelte +++ b/src/routes/docs/products/sites/+layout.svelte @@ -48,6 +48,10 @@ label: 'Domains', href: '/docs/products/sites/domains' }, + { + label: 'Environment variables', + href: '/docs/products/sites/environment-variables' + }, { label: 'Frameworks', href: '/docs/products/sites/frameworks' diff --git a/src/routes/docs/products/sites/develop/+page.markdoc b/src/routes/docs/products/sites/develop/+page.markdoc index ed8a2422b1..504172c701 100644 --- a/src/routes/docs/products/sites/develop/+page.markdoc +++ b/src/routes/docs/products/sites/develop/+page.markdoc @@ -28,41 +28,6 @@ You can configure your preferred rendering strategy through the following steps: ![Rendering strategy](/images/docs/sites/build-settings-rendering-ssr.png) {% /only_light %} -# **Accessing environment variables** - -Appwrite Sites lets you set static environment variables to pass constants and secrets such as API keys, connection strings, etc., to your sites. - -To set static environment variables, follow these steps: - -1. Navigate to your site on Appwrite Console. -2. Head to the **Settings** tab > **Environment variables** section. -3. Click on the **Create variable** button and add the key and value of the environment variable. -4. Select the **Secret** checkbox if you want to prevent any team member from reading the value of the environment variable after creation. -5. Click on the **Create** button and redeploy the site. - -{% only_dark %} -![Environment variables](/images/docs/sites/dark/env-variables.png) -{% /only_dark %} -{% only_light %} -![Environment variables](/images/docs/sites/env-variables.png) -{% /only_light %} - -You can also configure global variables that apply to all your sites in the **Settings** of your project. - -{% info title="Secret environment variables" %} - -Appwrite now allows you create secret environment variables, which are hidden from both the Appwrite Console and API. Once a variable is marked as secret, this action cannot be reversed. - -You can mark an environment variable as secret either at the time of creation or after it is created. - -{% /info %} - -## Appwrite-specific environment variables - -Appwrite passes the following environment variables into every deployed site by default. - -{% partial file="sites-env-vars.md" /%} - # Timeouts {% #timeouts %} Each request made to a path on an Appwrite Site has a set time limit, after which the request will timeout. Here are the steps to configure those timeout period: diff --git a/src/routes/docs/products/sites/environment-variables/+page.markdoc b/src/routes/docs/products/sites/environment-variables/+page.markdoc new file mode 100644 index 0000000000..fff8b25c42 --- /dev/null +++ b/src/routes/docs/products/sites/environment-variables/+page.markdoc @@ -0,0 +1,1220 @@ +--- +layout: article +title: Environment variables +description: Set environment variables for your Appwrite Sites to pass constants and secrets at build and runtime. +--- + +Appwrite Sites can read environment variables at build and runtime. Use them to pass constants and secrets such as API keys, connection strings, and feature flags without hardcoding them in your source. + +A site reads from three sources, in this order of precedence: + +1. **Project variables** are shared across every function and site in your project. Set them once and every site inherits them automatically. See [project variables](/docs/advanced/platform/environment-variables) for the platform-wide reference. +2. **Site variables** are scoped to a single site. Override a project variable for one site by setting the same key on the site itself. +3. **Appwrite-injected variables** are set by Appwrite at deployment time (for example, `APPWRITE_SITE_PROJECT_ID`). These take final precedence and cannot be overridden. + +{% info title="Redeployment required" %} +Variable changes only take effect on the next deployment. Redeploy your site after creating, updating, or deleting variables. +{% /info %} + +# Manage in the Console {% #console %} + +1. Navigate to your site in the Appwrite Console. +2. Open the **Settings** tab > **Environment variables** section. +3. Click **Create variable** and enter a key and value. +4. Optionally select the **Secret** checkbox to prevent any team member from reading the value after creation. +5. Click **Create**, then redeploy the site for the change to take effect. + +{% only_dark %} +![Site environment variables](/images/docs/sites/dark/env-variables.png) +{% /only_dark %} +{% only_light %} +![Site environment variables](/images/docs/sites/env-variables.png) +{% /only_light %} + +You can also configure global variables that apply to all your sites from your project's **Settings** page. See [project variables](/docs/advanced/platform/environment-variables) for details. + +# Manage with a Server SDK {% #server-sdks %} + +You can also manage site variables programmatically using a [Server SDK](/docs/sdks#server). Each call requires an [API key](/docs/advanced/platform/api-keys) with the `sites.write` scope to create, update, or delete variables, or the `sites.read` scope to list and read them. + +## Create a variable {% #create-variable %} + +{% multicode %} +```server-nodejs +import { Client, Sites } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.createVariable({ + siteId: '', + key: '', + value: '', + secret: false // optional +}); +``` +```server-deno +import { Client, Sites } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.createVariable({ + siteId: '', + key: '', + value: '', + secret: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$sites = new Sites($client); + +$result = $sites->createVariable( + siteId: '', + key: '', + value: '', + secret: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.sites import Sites +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +sites = Sites(client) + +result: Variable = sites.create_variable( + site_id = '', + key = '', + value = '', + secret = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +sites = Sites.new(client) + +result = sites.create_variable( + site_id: '', + key: '', + value: '', + secret: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Sites sites = new Sites(client); + +Variable result = await sites.CreateVariable( + siteId: "", + key: "", + value: "", + secret: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Sites sites = Sites(client); + +Variable result = await sites.createVariable( + siteId: '', + key: '', + value: '', + secret: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Sites + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val sites = Sites(client) + +val response = sites.createVariable( + siteId = "", + key = "", + value = "", + secret = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Sites; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Sites sites = new Sites(client); + +sites.createVariable( + "", // siteId + "", // key + "", // value + false, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let sites = Sites(client) + +let variable = try await sites.createVariable( + siteId: "", + key: "", + value: "", + secret: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +sites := appwrite.NewSites(client) + +response, error := sites.CreateVariable( + "", + "", + "", + appwrite.WithCreateVariableSecret(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Sites; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let sites = Sites::new(&client); + + let result = sites.create_variable( + "", + "", + "", + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## List variables {% #list-variables %} + +{% multicode %} +```server-nodejs +import { Client, Sites } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.listVariables({ + siteId: '' +}); +``` +```server-deno +import { Client, Sites } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.listVariables({ + siteId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$sites = new Sites($client); + +$result = $sites->listVariables( + siteId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.sites import Sites +from appwrite.models import VariableList + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +sites = Sites(client) + +result: VariableList = sites.list_variables( + site_id = '' +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +sites = Sites.new(client) + +result = sites.list_variables( + site_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Sites sites = new Sites(client); + +VariableList result = await sites.ListVariables( + siteId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Sites sites = Sites(client); + +VariableList result = await sites.listVariables( + siteId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Sites + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val sites = Sites(client) + +val response = sites.listVariables( + siteId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Sites; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Sites sites = new Sites(client); + +sites.listVariables( + "", // siteId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let sites = Sites(client) + +let variableList = try await sites.listVariables( + siteId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +sites := appwrite.NewSites(client) + +response, error := sites.ListVariables( + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Sites; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let sites = Sites::new(&client); + + let result = sites.list_variables( + "" + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Get a variable {% #get-variable %} + +{% multicode %} +```server-nodejs +import { Client, Sites } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.getVariable({ + siteId: '', + variableId: '' +}); +``` +```server-deno +import { Client, Sites } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.getVariable({ + siteId: '', + variableId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$sites = new Sites($client); + +$result = $sites->getVariable( + siteId: '', + variableId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.sites import Sites +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +sites = Sites(client) + +result: Variable = sites.get_variable( + site_id = '', + variable_id = '' +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +sites = Sites.new(client) + +result = sites.get_variable( + site_id: '', + variable_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Sites sites = new Sites(client); + +Variable result = await sites.GetVariable( + siteId: "", + variableId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Sites sites = Sites(client); + +Variable result = await sites.getVariable( + siteId: '', + variableId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Sites + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val sites = Sites(client) + +val response = sites.getVariable( + siteId = "", + variableId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Sites; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Sites sites = new Sites(client); + +sites.getVariable( + "", // siteId + "", // variableId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let sites = Sites(client) + +let variable = try await sites.getVariable( + siteId: "", + variableId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +sites := appwrite.NewSites(client) + +response, error := sites.GetVariable( + "", + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Sites; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let sites = Sites::new(&client); + + let result = sites.get_variable( + "", + "" + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Update a variable {% #update-variable %} + +You can change a variable's `key`, `value`, or `secret` flag. Marking a variable as secret is one-way. Once set, the value is no longer readable from the Console or API. + +{% multicode %} +```server-nodejs +import { Client, Sites } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.updateVariable({ + siteId: '', + variableId: '', + key: '', + value: '', // optional + secret: false // optional +}); +``` +```server-deno +import { Client, Sites } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.updateVariable({ + siteId: '', + variableId: '', + key: '', + value: '', // optional + secret: false // optional +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$sites = new Sites($client); + +$result = $sites->updateVariable( + siteId: '', + variableId: '', + key: '', + value: '', // optional + secret: false // optional +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.sites import Sites +from appwrite.models import Variable + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +sites = Sites(client) + +result: Variable = sites.update_variable( + site_id = '', + variable_id = '', + key = '', + value = '', # optional + secret = False # optional +) + +print(result.model_dump()) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +sites = Sites.new(client) + +result = sites.update_variable( + site_id: '', + variable_id: '', + key: '', + value: '', # optional + secret: false # optional +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Sites sites = new Sites(client); + +Variable result = await sites.UpdateVariable( + siteId: "", + variableId: "", + key: "", + value: "", // optional + secret: false // optional +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Sites sites = Sites(client); + +Variable result = await sites.updateVariable( + siteId: '', + variableId: '', + key: '', + value: '', // (optional) + secret: false, // (optional) +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Sites + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val sites = Sites(client) + +val response = sites.updateVariable( + siteId = "", + variableId = "", + key = "", + value = "", // optional + secret = false // optional +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Sites; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Sites sites = new Sites(client); + +sites.updateVariable( + "", // siteId + "", // variableId + "", // key + "", // value (optional) + false, // secret (optional) + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let sites = Sites(client) + +let variable = try await sites.updateVariable( + siteId: "", + variableId: "", + key: "", + value: "", // optional + secret: false // optional +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +sites := appwrite.NewSites(client) + +response, error := sites.UpdateVariable( + "", + "", + "", + appwrite.WithUpdateVariableValue(""), + appwrite.WithUpdateVariableSecret(false), +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Sites; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let sites = Sites::new(&client); + + let result = sites.update_variable( + "", + "", + "", + Some(""), // optional + Some(false) // optional + ).await?; + + let _ = result; + + Ok(()) +} +``` +{% /multicode %} + +## Delete a variable {% #delete-variable %} + +{% multicode %} +```server-nodejs +import { Client, Sites } from 'node-appwrite'; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.deleteVariable({ + siteId: '', + variableId: '' +}); +``` +```server-deno +import { Client, Sites } from "npm:node-appwrite"; + +const client = new Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +const sites = new Sites(client); + +const result = await sites.deleteVariable({ + siteId: '', + variableId: '' +}); +``` +```server-php +setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + ->setProject('') // Your project ID + ->setKey(''); // Your API key + +$sites = new Sites($client); + +$result = $sites->deleteVariable( + siteId: '', + variableId: '' +); +``` +```server-python +from appwrite.client import Client +from appwrite.services.sites import Sites + +client = Client() +client.set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint +client.set_project('') # Your project ID +client.set_key('') # Your API key + +sites = Sites(client) + +result = sites.delete_variable( + site_id = '', + variable_id = '' +) +``` +```server-ruby +require 'appwrite' + +include Appwrite + +client = Client.new + .set_endpoint('https://.cloud.appwrite.io/v1') # Your API Endpoint + .set_project('') # Your project ID + .set_key('') # Your API key + +sites = Sites.new(client) + +result = sites.delete_variable( + site_id: '', + variable_id: '' +) +``` +```server-dotnet +using Appwrite; +using Appwrite.Models; +using Appwrite.Services; + +Client client = new Client() + .SetEndPoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .SetProject("") // Your project ID + .SetKey(""); // Your API key + +Sites sites = new Sites(client); + +await sites.DeleteVariable( + siteId: "", + variableId: "" +); +``` +```server-dart +import 'package:dart_appwrite/dart_appwrite.dart'; + +Client client = Client() + .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint + .setProject('') // Your project ID + .setKey(''); // Your API key + +Sites sites = Sites(client); + +await sites.deleteVariable( + siteId: '', + variableId: '', +); +``` +```server-kotlin +import io.appwrite.Client +import io.appwrite.coroutines.CoroutineCallback +import io.appwrite.services.Sites + +val client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +val sites = Sites(client) + +val response = sites.deleteVariable( + siteId = "", + variableId = "" +) +``` +```server-java +import io.appwrite.Client; +import io.appwrite.coroutines.CoroutineCallback; +import io.appwrite.services.Sites; + +Client client = new Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey(""); // Your API key + +Sites sites = new Sites(client); + +sites.deleteVariable( + "", // siteId + "", // variableId + new CoroutineCallback<>((result, error) -> { + if (error != null) { + error.printStackTrace(); + return; + } + + System.out.println(result); + }) +); +``` +```server-swift +import Appwrite + +let client = Client() + .setEndpoint("https://.cloud.appwrite.io/v1") // Your API Endpoint + .setProject("") // Your project ID + .setKey("") // Your API key + +let sites = Sites(client) + +let result = try await sites.deleteVariable( + siteId: "", + variableId: "" +) +``` +```server-go +package main + +import ( + "fmt" + "github.com/appwrite/sdk-for-go/appwrite" +) + +client := appwrite.NewClient( + appwrite.WithEndpoint("https://.cloud.appwrite.io/v1"), + appwrite.WithProject(""), + appwrite.WithKey(""), +) + +sites := appwrite.NewSites(client) + +response, error := sites.DeleteVariable( + "", + "", +) +``` +```server-rust +use appwrite::Client; +use appwrite::services::Sites; + +#[tokio::main] +async fn main() -> Result<(), Box> { + let client = Client::new(); + client.set_endpoint("https://.cloud.appwrite.io/v1"); // Your API Endpoint + client.set_project(""); // Your project ID + client.set_key(""); // Your API key + + let sites = Sites::new(&client); + + sites.delete_variable( + "", + "" + ).await?; + + Ok(()) +} +``` +{% /multicode %} + +# Read variables in your site {% #read-variables %} + +Read variables inside your site using your framework's standard environment lookup. For SSR sites, variables are read at runtime; for static sites, variables marked for build are inlined at build time. + +For framework-specific guidance such as Next.js, SvelteKit, or Astro, see the [framework adapters](/docs/products/sites/frameworks). + +# Appwrite-injected variables {% #appwrite-variables %} + +Appwrite passes the following environment variables into every site deployment by default. They take precedence over your own variables, so do not set keys with the `APPWRITE_` prefix. + +{% partial file="sites-env-vars.md" /%} + +# Secret variables {% #secret-variables %} + +Mark a variable as **Secret** to hide its value from the Console and API after creation. Only the site runtime can read the value at build and runtime. Team members and external integrations cannot retrieve it after creation. + +You can mark a variable as secret either when you create it or by updating an existing variable. Marking a variable as secret cannot be reversed. To replace a secret value, delete the variable and create a new one with the same key. + +# Limits {% #limits %} + +| Field | Limit | +|----------------|------------------------------------------------| +| Variable ID | 36 characters, `a-z A-Z 0-9 . - _` | +| Key | 255 characters | +| Value | 8192 characters | +| Reserved keys | Any key starting with `APPWRITE_` is reserved | diff --git a/static/images/docs/functions/dark/env-variables.png b/static/images/docs/functions/dark/env-variables.png new file mode 100644 index 0000000000000000000000000000000000000000..0ca5098c3294dba8877ea87fa29a6b348cfae278 GIT binary patch literal 104486 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 literal 0 HcmV?d00001 From 1feca03ea04f2cd94a0b1987e247c97b5f3336b6 Mon Sep 17 00:00:00 2001 From: Atharva Deosthale Date: Mon, 27 Apr 2026 23:56:07 +0530 Subject: [PATCH 2/3] fixes and screenshots --- .optimize-cache.json | 2 ++ .../announcing-variables-api/+page.markdoc | 2 +- .../environment-variables/+page.markdoc | 14 ++++++++------ .../docs/platform/dark/env-variables.png | Bin 0 -> 109597 bytes static/images/docs/platform/env-variables.png | Bin 0 -> 109968 bytes 5 files changed, 11 insertions(+), 7 deletions(-) create mode 100644 static/images/docs/platform/dark/env-variables.png create mode 100644 static/images/docs/platform/env-variables.png diff --git a/.optimize-cache.json b/.optimize-cache.json index 1e360f4419..86e77c00e0 100644 --- a/.optimize-cache.json +++ b/.optimize-cache.json @@ -1445,7 +1445,9 @@ "images/docs/platform/dark/add-platform.png": "1bb0e7dba22556e64064951882d625532285fa80bed43fd77774f31545a15b0f", "images/docs/platform/dark/create-api-key.png": "f15696f0b28dfc46813d7185be11da8be89da72be66b1894cfcc7227036e4afa", "images/docs/platform/dark/create-webhook.png": "88f7f5c857fe986b5803c7df003c4db55faa79e3fa3135cf9491073d0b2736be", + "images/docs/platform/dark/env-variables.png": "da2a73b5d3420063e9869c40050b6168e5b5446a97772a26ca2a894e36021134", "images/docs/platform/dark/execution-details.png": "c0481ddc206447460f9d317ba8d421615066f67a50bc9ef41a8f71766ecffb14", + "images/docs/platform/env-variables.png": "16f95151e4f6ee9fb8056f075b9f5027fd91f0c2a28586c5624c3ffe9b7a1ee8", "images/docs/platform/execution-details.png": "ece1364b8b00254bbd982421b6eed6d7f519d34c4e80377fcaaa4cb5d5dd3f89", "images/docs/quick-starts/add-platform.png": "3b13ba983ea1d2529a1f34a719acef903ec0b58879ed511012280a28ccbde17e", "images/docs/quick-starts/create-project.png": "7fdb25def02c5dbdb08cd38c2d03b7b454c930194a900553e3e68d51cb28a1d5", diff --git a/src/routes/blog/post/announcing-variables-api/+page.markdoc b/src/routes/blog/post/announcing-variables-api/+page.markdoc index c1630d88ab..1b15cfba10 100644 --- a/src/routes/blog/post/announcing-variables-api/+page.markdoc +++ b/src/routes/blog/post/announcing-variables-api/+page.markdoc @@ -43,7 +43,7 @@ The relevant API key scopes are: - **`functions.read`** / **`functions.write`** for function variables - **`sites.read`** / **`sites.write`** for site variables -- **`projects.read`** / **`projects.write`** for project variables +- **`project.read`** / **`project.write`** for project variables ## Create a project variable diff --git a/src/routes/docs/advanced/platform/environment-variables/+page.markdoc b/src/routes/docs/advanced/platform/environment-variables/+page.markdoc index c7bca06393..5c6a78626f 100644 --- a/src/routes/docs/advanced/platform/environment-variables/+page.markdoc +++ b/src/routes/docs/advanced/platform/environment-variables/+page.markdoc @@ -35,27 +35,29 @@ Manage variables for a single site. # Manage in the Console {% #console %} -You can create and manage project variables from the Appwrite Console: +You can create and manage project variables from the Appwrite Console. The Console refers to them as **Global variables**: 1. Navigate to your project. -2. Open **Settings** > **Environment variables**. -3. Click **Create variable** and enter a key and value. +2. Open **Settings** and scroll to the **Global variables** section. +3. Click **Create a global variable** and enter a key and value. 4. Optionally select the **Secret** checkbox to prevent any team member from reading the value after creation. 5. Click **Create**, then redeploy your functions and sites for the change to take effect. {% only_dark %} -![Project environment variables](/images/docs/sites/dark/env-variables.png) +![Project Global variables in the Appwrite Console](/images/docs/platform/dark/env-variables.png) {% /only_dark %} {% only_light %} -![Project environment variables](/images/docs/sites/env-variables.png) +![Project Global variables in the Appwrite Console](/images/docs/platform/env-variables.png) {% /only_light %} # Manage with a Server SDK {% #server-sdks %} -You can also manage project variables programmatically using a [Server SDK](/docs/sdks#server). Each call requires an [API key](/docs/advanced/platform/api-keys) with the `projects.write` scope to create, update, or delete variables, or the `projects.read` scope to list and read them. +You can also manage project variables programmatically using a [Server SDK](/docs/sdks#server). Each call requires an [API key](/docs/advanced/platform/api-keys) with the `project.write` scope to create, update, or delete variables, or the `project.read` scope to list and read them. ## Create a variable {% #create-variable %} +Project variables require a caller-supplied `variableId`. Pass `ID.unique()` to let the SDK generate one, or provide a custom value (max 36 characters; allowed characters: `a-z A-Z 0-9 . - _`; cannot start with a special character). Function and site variables do not accept a `variableId` — Appwrite assigns one automatically. + {% multicode %} ```server-nodejs import { Client, Project } from 'node-appwrite'; diff --git a/static/images/docs/platform/dark/env-variables.png b/static/images/docs/platform/dark/env-variables.png new file mode 100644 index 0000000000000000000000000000000000000000..e90daea3c6adc203d9f55018bb07b1d2cf036d7e GIT binary patch literal 109597 zcmbTebyQYu_bqJD-Hmh#(v5(0NlTYB3L+pWArgXgr*ulAgdm_a7_>AgeeZo;*IH|?Ip^9TYASM=Xk=(NZrs3BkeAlDaRc$=jT^W5QEtIc zvTR~(Z`{DSp&JV)a>nz1ef+% z>{#vWIBC>=2ybvu(j_D(n_@*OW;UxQN$4l{U+yi8iCq8TX%N{?PIh~E|9&IABnnLc z&fmYJ+I4CF^G`_>E>q@+e|`-A*Or+j_&>krA2j#h&q!jBy`}q~583>mKh&WG7mx8s zN=nkz)lEuCAtSdo`6I-_!a_qs!_Uvp#ijnwm(!;{cCefN-qBe9NeNX`1e@;e%N&AD zT2Y}{b*C4ml5NR#I%jlJEwOXC-&?x|2bHd`N~)`;mzN%z{x4)N^f} zopN$=O8?xP1-7D|;9)KMWdG#-;Ut4O$zP3)FYg~#$C0X0&;&$%|Ju>PC?q7r%Bt8S zq-$V6PD&~xE35d=XT9v29Pdr^W=o`Co$&FmO!O6N1a(t5=GK4uM$%wrcKfQgt+9oQ zpGbBx4wmXhMOD@7o~RFTxHk`QZG_Xr|5-ROS_XCsV!;HC$97D4@4n;)SC(@iTiBr~ z$hPC!(3;zYKAC9P*(~L$n zQ4(Q(qL6zvF)~Zu)GYj8k6q%_1xId0MMf4C+1lBa#F;C|%U4uXME!FvPJXjJXUlkC zDg8=1N-Na5GxtUG&t$q(!zXJ+VJI53&X>Vo&8%YLM!34iWVwF~aipe@F-_>pYcI)i z?P_RLNq2R&_VlpIoo&dgsB|#2wdHDBGX32OdT+0J!z_e32gn9=AC#9il!o* zoSf9u&%Y(GYw%~r1)A$OKa6FS-=PY9vwGa*;As_M=TuaLck4m!;eP9tH1a(51p3T$ zOjy_uBEg1dT$c<^kW5wMqpH~IxV)rf5(awGc1HOCFM2k1cIVTNp{l>}{;o!_@L>MK zK<=2kI`?+*$@>)H23F_i>AdY2g%Vh8vqzR~RhR;eR6W!FJdmJS<%CVfISQ_7C|KV=O`+zq^d_(vwtpsekeLvWbigif!b7Mu^o)HrhBO@b= zh%~IMtmNj>vxq#lvRay*-Cg=Y&hnwiq}fMTcNBR)GAeF@CRS(AhIZ_G+wl*%!6{a) z!dHj*q@*l)iRUN#axyYSypp0dY;0@?A9eN@zv+B--;Iij`k0PbS6`pqXsI15(a_E^ zH#fI{qdT>=wS|SItQ?k;V;<+W_#>66l*;3Qu*_Tc&bBryDgmk@R&>I<+IAyl_GgEi zp+xM53*E87!6>V@&Ft*LBnRI~{mmR*1p#&&U2S)xxRHbltBU#Ty}x~YJxz!AUAps7 zR#tY!i-Zt5OQl+boEo zQ#Gu4*P&(qR>v=yaC?n#?5~zaL;j-+ANk(%aulm)U}xJ`VzfoSR&`a-lc+Rn-=1!y zvkZIO8Z_qzjJpiQ!lo-*G!I_DvM@ib@k?80k(1`kM&P^ zTZB%2n?BQ{t*P#ATgRPU6YP=>Mn;zu0oF%FX^lDan@?|^T~6bY?rQf4Ca)~>g=b#G zu^SxzDmBnRA`$nQ{8c&;ap(T~w2cxy9)V})8Rg~WVk|?-Ssf?)%hfWRTwD)A$wXW! z*qq~y8eblH9`9t$JxEsHTlyj5wiVeKNoDfMDV}0wbMxZQNNnIOGfPWC+}*?S=1V+m zvyGPOqt!v3-hgBlYEbKa<~mVhKhxkwWh~<^ z^COvuN$@!OAnVm7pJmTTj$CB)_31Su>FS7}sPg=?7D{}P8`j_K+q^z<+Z1>of7uB= z54}Z`lKGSjCrXGR11n{$Zk=@BY#?>H+cCW(!5Y6cC8j@f{`n1v^^!k0* zw?zKI$IZ>^Up3wx+f@BzSc^zbG4Y=Lvu8fDEgttZkI%N7YoGluEsT4jbOErIB)G^Xuu2{o+z$qRJK(;-jz9q+FG!rNQenQg6`=S5OP>&DC5TwV3MY#aNq+(s&6+T?Ze zZ2GgG1UY$X`u&&LS%)kA^Ig$&%pM`vWgY32-3AGPnygB?C`-^q-__UW=CO>CmlsDS zt90tQ!EUAc)nW;Pw_4>C)unioP%DD+RUYa+!^hz?IF(;H2~R{|S$$!qt4^1ip1)O$ z|9YEAhESkpm}$2;4_QOMYj4*z{HI~D;H`2PL7 zY5Ug~ezxjmhI;1av6=-cMxUHyr2W-ASNa~4RF;)}BH}Q{;3@amx0;@oNf-BZUHYDU zc0?6y^Xu2Ix|?r_Ik4yuX1{)Axf_!9?wyG1Mup3IP5#5w`cI2{N6kogW!ePz_(~z` z6=~#Uo*kc@JeV4aew4PmI%ut}o$%o*Zcz)2Ib$6&FrT6aDq~qY+yvE0g%n3I+ z~Hb;6BG3>6J8Xba;bJ7sjuqu*LGad;tJdiEY z`iM=jb5iW=?YE{I-#o#4N+qrI+}XL+IPCTpr+ZpmPdg*t#k7z){3@}%JV(q-q!Mve z)(fhws92f&g#X!#CeOFJ_5osTyC1O5H88NM|(7#}M*GXx#YBqY8-l1mkE*xE{W zfE7VWJSp0+7V9PP+u?Rd+D`3?S0JAGGjo6_?VW)u+jQ;G=J{lh>35(OJ3rFSKW+0 zEo>RaU zPEp=~42NEo#nt6SUR;Q1YXp_};q0k?yR|bix!6i-2(+Kfmk|`Kx4-YfYN(y!w_bv~RHCz0YVkxqp1MGb?5H+vDhDx$$w?y!vQ?DwSbX99f_e zLBnrneK;j~Jj-a7xlbLhJ&rCV%5hL4flxS z!wFKEw*)fB>m%h%DrvtLAE}A;N6|=SdOb*mU&nhw`lmPsKRlf3;jMwJ(9my?nfiYA zx8P>`5O(1i-$~>!5%U-zE;Tw^%$KL{BXW`cvTm_4T26iY>z>0v?rz0nDVbw{v5U2o zdpC?!T|Z=R)(oRq;408W2cyzeY13NX1Q_9aApfB}kKbN@d%T)Fh4J2#A1QqAgkA7v z9cE;oP1fOJ-pFP*t{=ZutX&!;aFF498KU#&HKKU6-I%0?d;;vYoN`$5`N3c>jwL|8 z%=f>$Zy@g9J`=tM)AFuT28jv=f=J%G_>GETeFy6!0;=hvJw>(~21HQz-`U$`+<*D2 zzaJGTw1V5z`+L$ZW`O@)oiZ~or7-2Y1-~jD-(DeJ+0L7|LJ8_KO?|O3ifd$s`+Am^ zOQVpp^T{_Z=VjMc=Iyf`;q2uQ^T(l>6oP7P{Z<|d;}6;6?+JUpHxtC+A1c<#!aL!( zBdcB1p^%Vk(Cv^Di(i~1I8K@zC*UfWdLS$;HF!QbxOhKI7j^HjsPJb z4fPf4GP)xFtn%DndgyJ)c3cDwsU!GCnd~Q=}|5i**_FlAfb-em%^HsV=P~j<+&vBD>X^Q(rSLc(b=O}M7 zYpj0gf2;+>{X47N(Uvgo@`H76)?%x6=eObhe%x*KKQ`{fv`SSSS-79g6Yd!?9teKc zCgw2yXx{l#F7lF2(q(mkft!16@{_Z$QyKdOI`KUTG(SdKh!tBRh5Y@!#nAJUyS9^v zi!XZ9-Q3!sXxzWQKi^G_h3i-6Yj1DA_(JPe7G@T<-xV#zyBk`XUtb&V#Zkoh3V%kw z?xPn5Gp&A*k>uh|Kv10@P9RafyB|Kgk}QFv_sMDTWS?bBl3nz>X$MU0o7c zo3=@OjM7rWPq&;r0Vw=y-2d^y5aeg>Zu+k z2AX|@3^h#%%0Or9G_#8kt-hjY#&LdJ<-1r5E1G02?n)DatKZ>qrgX^`qK<^z^(9Dq z$d{Q(Hq%dMSuI)BHqz44s2SvwA3%fi?pXKQg{2pT%=N zH8wWdEupSHcqM|2G#pJQS7!K$%}$5K60K2S%Ofl773>^9S?xRY%`cD2Mqj01TSa+hejEim&zNdVnoXM2zci@5TMFMXIhXc&Dfeb)#MAqS+%LIY*b zHCrZBa@5uNTewd2o-#l^3QPyK(czxC;F^x>;$>q22>0vL4cJGrjI3ZoXf8bVmz2=f zDcumt%#OC)62yZLo31Wj+KrBljgO68?DrCVBvn9%0|cFi=-#J>X6OEZb(wi+Nyr4A zA+RIir86^3)t1UycuV&vT1qQ^THk(bck?!5mE1>e%brYDbrh1xib{_HZ|bY)Xotat zKIHMcANA$SoKWcX5ymG9Jg{i4lepM@NhvAIb!uVZ#ny=NdgbvJu7g`==#AdE5m;G0 zwYYqT?ES5u9Osc_&-xz8x?!c_U*?b) z!R=6iB*bZUH03svw}xU;f)PbvuH?2g$*xrxg(JtSZ(RS7J>2LZG7zhimYH<*VlHLl zd+I^}k3#uGO5J^x2rk8hFnXIivYq%QE&{_N$;FqsdK7vjj?S@44;Q1jT-)m#2Ywsg zm>s8x$R(dN;xPUkmG=hY7NXWM9|jgyLO8Q13VmRrw9vTUZRGIqnNk~#8bj@JW6dHB z8JjeK`WR?v`k&oVbG4Hg9z4Ka5ae7lCF&WhUm!ITEFz%|;@w|NG?_zc@EoRc<4$K; z?1>+KXTNKM|AnZks!GEo%hcNX>TuIHVTXpPhY|m0MA)agI%%0kB}}y4);AB{;#Hty z`7q}pNvlae9sjuc>gGjO7@J8G?W3y{>}OLfkBZKBeX)CJ9*Wd>oE)4i@(_nTRNhI< zWu`I^nb_fcG)zY;dj9*D(M$e|W}d8-F5csJU+sZ>=v6-Iz^E3Xr*|gu$aYVMB&q} zsfcR&=bo3l)55u2a;MsdY+TmZ8 z14PfBJ`MfpU$vVznH=}=fL$q`_0O=5iJ1G&4YXUQLT0N1CD>t6A)gM{;s8{!v6aY# zENPd|YqM30@hL^|mytRa!WG_a3(?}2$KKx( zN?T4)>}a{{rF%rh!&d1;g=mIPD3|d}-Y|7iDSEo_u1*DnF|*iO&wWtI_xSOmp7Oz* z2AM){6%8jo4%F~VCv<>%)U zbL0!s2G*cGDD%1Sgxd?yVD5EFB-o#R-26cCg{x}<@6A}GCtW+UbZv$=#&AQh7V@6a zdSet6r=}cj&paK-4f%X|OYu3tnfQXn-)}Q5Dc~Y)A+fXwN1x=88K}>5Q8>dQUszab z5d`N(xln(Vq|xv)`m>KkDV%#+nz7%hI_xl2Vp)sz#_gP(oKmw%Ha?$n!biZ9n>X5E z$!Z;3UL5(vo8LY!JG^*uJl$N=j2XGZtd(i}Ex(yVk3BD1Sx0t% zaerr5=$<7Ww2**du)?YIQ@LtpR?H4*&Sd44c5PU9AtUc}|#3f8K3vR% zhJcM}*ac^lU8UY_ds@`PiNo-iXG^m%Rw;o^MYGEN_2$_AHZXKKIhr4_gE?Z%JjqUP z3hI2Eqf-M$GlpQ@p*KUk*=}sW#ODO@HuXQJ6VKj=(SEkV?E8-&kL6GdZWwVVnfv%8 zE+9ZY&2pp=a?)a}eV}pQ^B}7CwcuXZ%L6;EXY>@C=4{A~Guut6gTRt_pB*Z!BKkYS zgBmwq3VcEiEmH^R&Jg&KhDDj2t3C)_T?{7~*Zgf4C%4C5?)Dk_kf}%BlP5*gQMjw19Qb%ftYu-Ea^N6D`8jv4}vmTnOX)733rZ`LWOldkwTuVH#(({V) z)o_HSutjuREj&94{qPS?eN*_gzEA7 zu_KjXenqV#keBUoEsHCuGYv^WpsD&RM~ zSPc`zQ8O|$)Y7sDZ+xZ;HN9_Xm7rmATbep8eONG_d@uD6y^Aa~7q`;O4 zJI+ll&ih4}bs8YE<2)>LUjA9c`1-gIOG_Aw#iS{%M>-d(By@&3zxo2y;#s#|e&o9} zYk!+njh@*0?AbFbt9;hs&4mT6eC1Wh!=F8|jbG}N8TM}`JR)~=bgYZad=<<>PspmJ z`^hOVDSUPD(Q{}7FVFXTnw6{D_O}zQE4Km~AvJOX+xJ-PmE{<|!!($5kvqiX{ z46VQkdYC4t?qdpYZY`9fsm|xV#I-&boRwYrEtj3*9sUbqWDJs5D#WgTHpZmVaXI=% zYo*GQqHSkn@9|hbJV8 zdl?_|)S(>+7ep<|sTyX`_xn}-Yf=%jg_eQpUo zKmQ>R%M|=}qj0!Q4PbXD$k(L$qVD*fZ3@^>(aBLPFckJ3QC&#+mltQVxJZ6dIjT6hhx3un z(E{xw?_+M?x3s#KR!IdGX@402WzeI$&H<%98 zCTMFrR#sM>#fT@CJ`y`zxTHJ&;9L>uj(^YcHuZ2|fM|c`*xU5qrLU0sAOcr3ov7os zqv@J$CTcLJRVQke04N)mAPzx*57~3Fol4qfrKM{%v;v@!BeC<}*&fYtDCs8#Q_oV)^kM9IT4a5iP~!~<`ZT@uDi90-ms zC`gREcW1$#&hpi@PGy_xzKf@}VOp$2g%F&>d4}27Xa6r3FpP;o$XORIxQ1>(O*^+V zG$`5{Lft8Oq`-HXXcFOZyhD>tCQl_`|32f>Yl=|8Dkk})6sUe*Kd6q0qXb<%HnjbW z@JExnSYBGCZ+x7rmy+^cCVuEbf*1;8ZH59>0um;f*vmr#RVkLx2Y$eU&c)|6x1tQ8 zlX2z>gcoJ?ukC2D+S;BAs?`Zzm}cLeR_%Jj(7 zw&pq4V`=jY6N8z7u`w1#M(v!~XzadqiJ*R}UxgLS4c*Al-2vW`ioA25OW)4iJV$gX z?)_q(*^||u*q(cih$7GD(^F9vTU@23IjMw>x`HVw+DH&5-(1#xVBx>ia0rUr7u=EL zfYAC}(0(5srQ7hpa4ErFJwxuF%XT6ECSR_)U_+Bn?kul-FcXw-O(NplhAa8vu~p21 zRmP)JdArx$u_GE@DtwCF1%B1ld~wmEqq;2CW{)4=^j?tq$?}i8M7l!2?EChDX#RFqw`eZ;vG=-e63@s!uc z4<{yv^z78h-H9>jtvrH)!fGIo910CRKDafwxw(5nVmV4mOJieWbK=EHAO2mEt~a^$ zkIEil#czfWY!eXnbo~|}{wduYH4qx&?;k4-A2x?2OG-^mO-{~RZIGm*WTq3+8oW+R z;NQTA#LJH8Y%Z~xP5Z`tf3Wg)EG<%V({mO^t)3eM*Wc{?ip}iF6SPkc&d;MV?yKBo zWMqtTva_?p!^bZQyS_v~ROHXlwxk(4D#0WJZB7^ELBHk>Buq~aqBlyU{@=4sC2u@s;mQ0T zLr;`lKx3r`5BU-FDGbV+qG2TgA~8D)0dn2_eyF&Rvo<3!P*vZ?a%2DhtUkvqCVv<9 z`Y#gR>u37=p{zl2$Rmijq zlH7#M&uC~O|LaqtXZm8v_wUtFxc)DWqyHzH(*NZ{$_$dhw=^|1m6Yx(DJg+KWNy9| z^q)J~yP{`cV4!d7%*A;Z6-Di>4@*EVLsVJo#wk!6tV%<}$VgP%2#4nH?=RdZkp#z6 zWktou>gv$YP)uy!eHI0J0=eKUb9?*wl@)|t9#K)le+*FpIN2feh$N~J5fL>XKfZAO zwtwoPtEH8DpdjH03m+wFZ)ZnGOAF_Q;otr6eARDRNbl-;*wN7ew4}Tcm9RE-P-t~E zW?Xbvmptpgj;$C*Q`xUcuN4qm6?;zLj*;FL6%|3NqoqYK75bkIlox)*g&2z#MELzK z%bVCNbhTqME;$ww@>F^H<=D8mq^Kwya&l`F9+r(wN;5MvLF<3_W&l%}l|-AfTvEzJ zK`8kklulb)+sewSzrWuwey96J^|#5%mW~eDy3uGcqs*0A#Z|xf|9mBPup~w0o9Or) zapTyZmV87+MBUxpYC+jKIfY?f+`w*S6>4jhRaaLZteV-{BHon$ccEe)n;L)ZigDsz z#g!{5DG3V;6T^J-QJSuB5wV8XJ|@}4;UUOhu8Gl0bS`XBJ>Xj2M3}cFQ-J12|oV~2p>or zmj6ccf`631b%eXSyVw2?0WmSL+ejEBVqV9=xO9-y7**12EG%-*zJSKQ)Ez4~kovKM zn1Dqi7bvLzTC*gp1Q@ZfRBVO63=D8z8}X1ZD1~{MnQcI|+TGnfCZ(kGULDB0bKi3k zlsRbnQM%uWxP1V5p!&(;>gvhwueYT?R8)}g+kqU{-jl$d3To50M2_NIJ?Lzp2YXba zi;JcN8M5P8z7*OtdD6YkSSD3kIy&57lt;zd)m2q%a9L$#4A)r+9UYy8o49Qy___Yy zd7lh*{rtHFkR8t9T<+qx#A`(v*x;GZ9-37a-OIfh*Z=CdqiZnn+bNg#wJaVk?mbKM zjg5^#N27n^fj8#jhs4yv?_|0>r9?4k+MQ6^0>Neg)(6CiK5na@X{(^JEida-n10=E zI{P^}DM~~0V59vC(qJ+DC{TQ$F-aQu@%NXTh!+yB?M4q_i=UfXS-GAb*fKE{kn&hj z>jf--O9b1*5~c8qI^b<{qrfSI4oqm1=N~k3Xd;t1AK$`o%Js(&C*hJz`>66xm`*Oj z>*ADeA?D_7q=g@;I{!VUUC8v`yd(bcYf3x>LlWh)S-v6OtH8FAWxN)=SiI#oMykrn zaRZ0}s4E)K*5HUoH$hO2Mudk4BHfH%INqK2J>Nx^1e+6@W9|cgq_d-KamTr~Fi_@64E;q;`Tb;0ZfBhgxJypw0f<>%;icy9SSYDH^A{g(E{i8cu-Yb;orqaIeBG~ zC3s7(ZG0T5Cs@(l5?}88v3YL%(LmBmXQ_)pnrMm3R|nKq_OG4{zYizlQ?!FE-s}~> zDlz=D2mOG4jUCIa`MJ5h<=%3Uhiz1XH_#KpzsX%rL`)*Jyw;**eEpF6J;pz9mv z*Qf`BjlO>UTE(6H8lunN-~Y`US@8TZxH)a2)Hd!hqd(%}mh*2{%n>=S%;oK2jG6~Qdz_KfrHjB{HQadtv^v~R=~ z3k69fuPn^X%`IoJq$%lCRm*uPU%3r`ODyuOMT~#^^eIz~I#nMd9^PEwq}sQh()>ry z;6s#dV>fk}xiTs^|1{>3VoqGp0(3!0L3VK@_Dh)`Eocb`&PXtrpQ(hd_uwWR0X+nlJyB_l3CA^MDUJlnq5uI@(P zj+csh&ocMpjXduJ4gMhN}4&(e3&O72AnDDb|$(SB`Thz%U&d&5sv zf}Fg(AEiU^*4DlAm6Hcb4Fq0bmX?%&GY4ww@cf&=K*(vmlamxJ6V@5tLHkd>-HGT) z72p_n@Y=?sK;<2on3o_Ktt%u@M@YshDk>y#{&hSyebjbz7qHo(tEv!ZUC6S#rz*SC zdGqbp06Hp7#ob-dPIXKQF}i!fk`Lz=D2fb$+_a(SMcn;)8}d&b>Oro>=b}&MynRNTnD@~f^oV=!I*eeM`Z~0Di9aF* zGs5<+?E+52(X*7TRP?g8wgv)_nT7AUmZ4#qmn#G>GV+^>3eI?&DEa4T7mK;rNbS+s zNMuN4tUvH1yEpF(fv(~m54F=jMjp46wliwf)u)FwNdQjOr!VdW6DaMZj6AcUuHF68V>QE6l1RnwshU9onjDd3j__)bhhYY*y z;I>66oJ%nF!B5KctGTJE)o25vFwCv2h^VMkEw6Jh7qe-aBvrq4*NjA$vZFLJUB&(& zjo68-xOgIt_V7?qnf-K*gHy%0G)6)d5KC-&k~ya8^)GCh=~(^B%F00Ve{bA)3cj14 z8O=MtzxqR5f%oGGJegoXTP#%1iQmqFY>I;TV{-B{1SUjju|e%mP(HBkh%)0!$|G^| z^Fw0w*^(}Q;ZW<5E+MZVzcEG7l@HjR2+632b)g0&pGw}6L*;88#vL3Jzf0%v3CMl0~E9UN-uxr5AN>5Asx+hrK%BQrWjb7%7f_!k|fQ*^h ztxIwRSv(q{C^*NwPk(*y?p9!+xMudg8ZUlfd`KomDg+66W6asYQd&baz3IeC*2~Ll z`6n1|?0D0eg@jJP$PIVv^87ioc1cn$;>(w3V3-~*RBs&|)HFvx;fiN{be%Vj#R9_` zz_65IxY5*k+xVx;a{_$_crv2G6iy6UcRTc^;0<3{I#t7a_jE^h6<$6L9c!ftp z|MC^GilpT0zYE#w-xJK8Y@3bZ&os5TPJTggbvIQ|FN4bw8K1LFu*-lona*~(J(QritE}waTElZDA5ierjDgU;fZ7ho zEditts4zOFWu~t$OG@?K-odt{bM{$53Jr1|?|GxSjPdfyF5=-v*yFl)dxy@@7`w zj6#sY1)waxSdDR7kPJjaL`J4->d1B7p7s}4U;@`^`xS75@3&7y1E;U8*NrbnCTgPr zMg}@n!eJ$g_S=va*})z>vO03J$MRP-FOwq;M8?MT@aoF(h;$J!f`w2@SA zyiOLA#Jo>SbSoth^!4<>21M8sERE8w^1F!k`dQo5X4mwSzZ+`Pr3Jw_5)97(FgjOF z5d4(5pjG2AgG)|6(Rg;%V6q8v1VI2eQH$>gJscbbnbi#p;pfnMxOT@dul zTfXn;-T}*;i<6VxRJ{uburgiXrQ>@xiO_>m1DZBIA>rb-?~lPjsmqDxs~fJ5$_y1$ zELwxYdu-vC@$0SEe{GAgV#FgT_CVpg_S>~Hx5eT2pn`iF=A%@EzQ!_n|A!gEi7EY! zpppEYg5zyuqyP^OvZG_A#yA%j*Vii^$MS&}1hT*Hi;BMX_cv+2?2W_MeF~!*B-z&n zoMWW-6vlPWAL~{KN@E3JhVbLU?1#4~XN`ls{l&%@PsoC90M_1^^=2sHU01Ncz%hOV z799XNJ?uD{rA;3D`4WD&P7Az1ZHPu0iUM!jbe-cMj9N_)lmZJM$D--l5$4eL={b6u zkTXmelyaElPa4`>+1QG>+Uba^9k!wYfH~IiWB-2+fv93885F6 z25(KFA|c*~S)ws)*O2Q}Db+DF6c;OpkjxSx;aE{qQ~B{@*xR?t>pf&7`X;*hNxJ*3 zW$PX&T1imW!Iz23PyQkbJai?-jrth5%RTW=;f$!sn!Yw0ff@(a+ItZIXzGfKiyIp+ z`g7#mwpAQ6)hbLMNT+i?etn=`1g92!%Ya@DC>=Squ@RX#In`*#;sFv%QLIikPK1%p zTxT-OJs7vph;#+hE|_khcRGSJzxEPB+u*%cH)QOo<|~N+C>17`aSrb#j)8Tj)K`KQ z_ARu&FjxZ-1QKnQ+jg(XXZM@YhzhoLwm9|+_Jp<6bvcgB7!-myV~0ma4pa3%py4eu zQT=3KZmy}73XNJvXR#-qy3bEm-?%q8G2W)W!Phm`0xaH-mPkq1V4>(486~NJV0tCJ zcW4hid#S^=-<6X2R(Cp^W*(?}z_ZiIhJ7hajEx-x9hbwX{>A0F$Hv-Bvv^0NPKoZ# zP^_BCp(0Iaq=IdL8yPOv=`^N5iAU(TBiVF3hhE4;vewR>q5?rd1zd}P(Zf`l|+)lb}*ms*&OA7q(!y1|8Ad7f<;B6XD3gOcp*q{zAD{?%VkI;YWij zew8}dLDPu`NQ`6fWHO2O*w`?{A!Y&u=jP{cBR=?U{FPZ?<2!V7Q_$Iq5h3L!nZK^| z4romoc1-~F7U+T>V`HSKcLbkHPz1I<9V)zuj-RuBovpCntk(Hn`E0bT;`q$9p^~IQ z+YLXs1iNlaYpYBez!d5qF#Iv|$r)KsX6cd2+XI@pFYdqx3VG};01%hae)_9~g=MMT zZnAC{)`cu5I`StJ0dR<&0Y26b(!XKIkK*AO|IX*Gbo3tBVRJ7{Q zY_FylmcwL|4T5CQXn&2p$e70yW#t}4fl4PB#-g;55B^}$tx*Xq)N#Z1Qf8LxN}sx1 z5A>@x<~R(|SkLb9n&UP>PyN*&S;~TfYYtuSIVrbA*B8IrO=nv#LvUgmv!t}IlW5c| zg+{XS79Im5W0N;IG@I7u=Ajv$56CQpTS9P57oKhk;AY(X&I(ht+!%j8Ot7UKt9?~cG$d}5-` z^PL>1>9%3FQO&``+Nb7uxY1vzE;YnL+t9FF3L`tfwZjr6-ZNs&OLSTHfqs`1QvH3W z1(X!3XW@W=f`Wp8up)SwwaaHePC#n}b0(_k2QDvOlz`2>25i4c?^}nUl&EBgHG=Nh z)KsuwDQ2_Te7=Xim2+)8g6Xu%N=Im)rRU|)XPUel{=?#Rmp#8#q`VYK{J4(%cK@$m zoV#`pm6ctNsc`!->gb0@k*8axNcOpFvr$^f+5R1?Z71C7Qse%3- z^82h|xp5;5E!w6B84KU6%pyW=ICXw8+!`>~`oZ1NVo3jsi%$ z3B!D}lq=k3(o@63gmdUYgLwoxaSy;sQ@yda1VjKZZ=FbXBamugc2dI!sDWFI51>L%=7bEOsa9K zg5w5wLgh2KZvk%=XaW8AIP@+f1GdJ`pTWCN!{R-E zdwy+?Kj;@U@)kM*V0k8(?ZT*O?-a9m&R!7Scz}#%3O@2(u^S-zWH0LgRt~0tDfX>wPD#{ z{`$q=f*4ZbUkDNbIU!+k{xC1AsP=Ox$8f9wWBEYSu~#O62oaaUWsW4fWJ!z~W7del z8v&Ixl8g`SBtT!g#!fFj5Q9^jFeTziIqod$yxnn#L?wG#%!;fBE@l8duUz~AL!iI1 z(Dn38h0ySaELGkZI*AYcg<%#rlX_WMS;Dk!9UYciau%5_7VUwsp;-SGh$9D&ByhvUW&@fujp@D($iIS0V4uuj?d$L*L4@Fqe?nhQ(3v%m(>bz zla5xSDe3lyeOQqm+FPOCzA8k%Iyb&n%f^Y%M2i^f9w zYZwKbEg%W6t*Mbs(|X6pteGj{2T>4W&%wdr@jB!;oaDL$VA$Vgzyxee%o43nK3O;v zw0`7&ZXAR3Cry0!UIsR59S*+@3#wRj>ZY@3XM1h8M>YWcWTY`t~+V5yZ77b09pu zyuD#}))p2JR&TCeZ^^@D7-5ZafmDd9&^|rw(-lQ?^XAPeXGL!t&>Lo30;8?KGz(bA z8|bLTMreqnyI(-g&BmL1u{r*yVY>-`T+YUZ8G)=&{J4mY>|ebjhBZxsHP*i~^jEpb z421hNaj37KEgMN8R0VT@mFRx0Z?GYI3BADYA_7^y-t*7tx$6c*{|<8o9TZ^3M3w$ zo_VV`-mhqou+(^1#(vTqaT zpCxPi(%t6ZY2nMGCLrXKSBa&Xpmy(o6lZXk#YBkG#ZvmT++_GgrU7X*0qJ0pK)ge! zO{gqHXf7IM6&_@>0Qrnpf-&>%fco^A{t9Ax2><*~5XQ(*SB26+Rx+<`%zs5AFFQd$ zEyi!n*SuIjlpT75^mR{6(<+q9{f|u58W?K}G#Q}vU%#|z(f)Z8M9@FKheCtr{r7be zK^RPf*WVt5u^iP?q4eLYlh7WBF~%-g@+l~UfD(?!bwjPc@L9;pn-3o}lesOS5zJFv z0A|S3!$V;#9f*L5iHYJjBErI+o}PsW`uh3_tdDvI2M57BAY^rU1TQ>LTJZNba~Q42 zide2mP9}XK*JCCsDhfb=K6(TBf4O_-U>k#`jg2Sec%=8i!I3~ll-l=_O|>t-CzUzoCoS!QOsD5_qK-3biK<=UY- zjb=XZ2lkeUiAjm{wxoo`!US+?id3n97on412Gs-rc^?T4j9L}00J2cjQveSlt9A)Y z2g|T*^4gCN_4Z;PB}!M_5L^Dc8%UJDq5LS(Q_jiT*` z+)jISB)PyAq(3;fl)_&8k6Vs`;Rk+^wgo6S-*d;Z+$8;5Sr$;;fh&m!35l+v0*s{8z#>ZhmN!Ny!1QjM*F;G!iz%d`s8lOk7zx@G( zAR3)MVyywWG%~*TGoMd>elLTOVwkIj#@Z#f90X$9)*#G@kG8j+r&?Mh7c?nCujwpv z4uW1t8O0RAB9z>nt#7`%y4GBGD6_Cp-2D7d*(YF5-3MHSnRa8`;GUlXtK1I0>@g&# zyIO@d_V$z@CB4^TfkOZwOkEJg7NjURFj`hzpvHZ)8_R|c$=KMqV$kA`Fo2tfDZIA* z*?|QGOitufR2*msfk?Yp3{>Rgp&76-iPkyPfuOq@H+ktz%mN!GwFHQ4?G8YKcOqjVANDE?zn6(PkfI)gPQWnnYelCc>(3hvQ4E$pvv-%{w zc>-2f{WJ3>lWID3YZvPK0qEu6EdjtWl>kI{0#7JUG{F$*5COL#08aT>Ni3WZbX+tB zlWb{JUUvH6w^D%}9ob($t2uD?Ec!RpL01616VA(Pz?3bs50?@V6bx4EL~?q0yn|~f z1MMZq)BuKyWAY<9@{QBU&@n%~*Dif;(=mR}1gl)D2=6WK8s0P?#F1?J^(@fZnkT#_ zBE*8f?$L(=U4N5)Kc@gl zB4;N?8eCj|wN{Y3hDA0gCQZ2Bm~F?!~7rwJa-)(Dty4ir!k20?Ac92IaHMI{zh| zgFH@wTAb??bXGJATT^kvvQaRlv4Zn=l9{Wl5tQVZITvp84vZlVZX^#IXtMjBw*8U( zU^D%hw2b&sr0i>98P(GtsUsj*$j<09D6uZ)2)?whEQW4pzB97(414qDDdIqMBpI(w z-};CHwTA?)A6iaK{#HkcVfr}Q!%w77KYQU~z4oWd(xY`ic_Y2oq)~>1gd`6(vfI}$ zF@QEFu=bS`wXp#p5$R*-G8QDl6gFm>9Xca6fd>(NZh8epiYqQV4dwd95imn`x!bwD zww0}4`)v4wbtHf-~)%FMDs2$Sx}@6_UL| zGDAs3kyMCK$lhc|C0kYzNw%`1GLle~RaP01S$@y^oX`1wzrXXxc|1-X-0u7JeqGn~ zT-R>QzBC_#y&X?h4S?TP8qcxz2OCDx?;IEgH zp7TE44h#sukPAoU8u%jXagYhXE4?+-q zY2i>PAUyGt@e^7P=j3DFrhY{+H&Ci3Lq@@g%D;tUVA|W)GmzNH%oq7n_5F=?3Pdif zH-|H~OcVg{Ii~~Hq%Ab_Y)TaMWg$Qp|1>En zw^XX(+%MtS#Kf>Y#N!JlHN7Na>v#v}0A6pXV&1Vi3%9CHMMO^*1HtG~fBn0-=3mq1 z$gf|mtBTxyeLHZh!Gk}+al_yU`mhW|Ysm(q+>VYBnTfyeaVz%dzE4pc<5utlm#5jt zp`~@DEA4g?KhLjk-!8`A;8~?e1`Sxuz=ifbL%a@c6r1J>Fd`n&_926oh$Ot-A8Wm? zudA>BYIydG``Ar^llq#n@>WRg2$D4d=^YeAz+a~oEq!R?G;8aqZRhmG$x}&nf^;|u zG7cJaC#@rRa;F$7CK7Jmy7g(mTGM@$grdp6U`$7g>Tdx7~H+Q{zSR*taT)F-B$d|8wDC*XLQBVw4T-l5l zjKpg{i$Sw6A-GP$&nE_ zTPaVm;kgHmweqW1-PD@Y&OF81I` znFuqZ4B=!T7tS~u#2bx+xV8TM5%fp8L9t?iKn0|i2lu9Q8yZ@Asc2JqKH`*jW510i zasFdTI(up|i*yzz`NO@-G$wR66}L&Ee?wZ2YKo@)Hu6#SdH?QCJ#5DPj|w5>v(ixGbKCb$YZZV|Dkbx1%Xi zwmgQJ`#qL&Bm~&uNq!ib_wyR7@W9YeozLd>Y@O6gx`S4N9K}DO$beVc0%IM3fTw8l zmlxdf#Oh4PNJ=-~SMV%l zF;5>180K|uX6Etv+q8i~xP%E&1Z4-5X5z$hoIO@++dtqc=ZRrCaM})k2`Q(6rU3=6 z?%k5sJbhk_A~vgnH7UXRxfYbg7h70lJu1E2iPGF>t2Xa&WXsi(*{sfi2_k zOS@z4Gb|x@cw*MpQVkXdSlB(Y(QX13Ow`@MZ<4V8whzcGsc5zv_0D@TiH(ilM^eGL zmv`d9Y4~)2ERIyW@8Lg#Oer$59@P46BZ>i8y$wMTA3MqA2?ZG?2Z(14L1+MaL$Fj5d@=k7Rnz#WD&efX) z4vMt4slo`~!$Aj;igRp#4~5Z{HybSXD>}7gHKpT3OCM2oL_$Z_TYAZaHhkpk&jboy z3!0#5bm8=zvOBVNSe?WReR*aY5jgE*+V`Y$b6Jv2x7S+-50Z);A1$@WQeVV{q%B+| z>t0pRsC^WjgNk zal%=Ww##q7ddu3W z{fw$*WPrJj-@*A0qX{C8nnA|M$*A&|OF>2q3=Bf_E(BPK_~_I1qwX_y7cYh|G6_e& zR8()vg{x4O^slX~hF8hYWvTYSpUDgI{Y!Lu7U~SI5*Te@-514zMlz^im9} zTrbe5WX~SF_=eqWSd!c=MR22-=h4)Hv_d(yF?`l+%7uG$!=(2|Ai z-P^HSkdr%|$4b)1CNr4&R#W2scP%n;a2i&QGR0JO;b#)zH{`FE(3GIn0)hR%a4J@;B?Wq$lvpFh_HRJHHEqRf%zl;9J{ev__r8`vVQhoHE$loU6Bis*n|-=gPM1T0Rp9FztP zq4g`G$*!g8*XZhdzOT(4Od0(FLf{6t<;lA0_w>}%pK8}jfF-vz{)`G&xl`yiEp0U9 zuN?T!*v&1f^>rPHHjrq#FRq>)9v-$?1v5U1Htpl>aFX+w_3J(6tpGY|g}(my(abG` z&?r42sXL-g&;EG?NqFh${r>z8Qh+@k&E1zd5!xw7DAt$-7@1jb&JDPblauFILoB|r zvL`B&lqBC*auOoTmEXTZDg#9*=x;ysT;!9QAOHGFZOWk7s*WoAx=3h-xbN0t8we~L zb-Iq%s92@`*#=i}8pY2>+z)6T|DL?Q_XtW%;8oGnV$EUQ-7IasuP<4YW}mdx|EIrb zgc1m}Qa4UE|1D%W0X||0wU%MJLOdQ@*&`4?2+*xPbf|%-;=GwK3FtP7TL?S+&P?R#2DwWM7kQ|XE<XKty{w%Le+R)<+qhqRP^&Q0jK?{%=(@sl!vqM zZsLWUY?VjZQbjBrbN+xG&!-yG^?0twk6rI^$QR)b)r{sz)jv+bD;I}&w+tWezh3E3 z!u(T0>obeGbB-G;kl}9ho@kFNspp8y`;04oVJ|wK0U$EDi53Fi8va%nn-mza`-0;< z%mkaB4aO$-R0lZtF+{+^_XrQv-178$KupOjX-~J;zh8^u)_ZXH7@$AT0~khCr}rY! zD`y5zg~XW(nyd=*Q-Py9VUq`sxUsetwf7hq{eFrone`OSLzCz=k?( zd+8EDe$hm-4jX7)C@Dctzc7g5uk-Mc_SrZ>D5oqwZH9nW%_CE zRLbOT6V06M4!%n#loS=MR^NPj!^g*`+OcCuq3(i#u=ece%onfY&o{@$T1rQ?W_0^sSgA7vM@ZnA3MW%V5a|R|I!y=CgAweq)=4|@ef@zzDNb83VkyKUPhGQwLg)nx`=Znt6hLGjt)$$GemfRge#va5m*FvX{bAy3}K1F z_mZ+45d6o-5clu*ma@YkA^f?WY^X`dS-yY3Wc;g{A#+t~w|Eh6kVDJ6cL?kA7V*b> zR`KFRvh*H$dejeUCxo{4ch2(P*3f;YciP3>9lA;b%JPbetDqLb!^0B`-~haJ^QN|3 zx+U5OjYz(mjpB@i7uN1fS3m>1TNyQ8*_EMkm~!HKHBcgL?&Y~BU)@-qK8PgOr)QIh zL9m?$2d}3PX$>m}#N3Uo_UX^BVXR*^j60Zc3TWtu{5Z#NsD&7*(qT~7y{GecYaQx& z!AWnB`erC#;obtW_wN4lOHTRd5o~OOq%>&=wKy<5Mj;c7Xbb#QI&e}VX2mQ_O9&-6 zz0rK~i$&kPW4GQxg_V1f;x>%t#AFVet-QS4yZ)74srvn6cGP|Z=M)lJ{x!A0&5p;% zp(hLHvBa#TJ}|HeO}++?T@0wS7mgpw(DA?)fg6H(l%Ti<#S}l_vu`W@T`jtnFl zvcR1o7X&Ud@agF18jq9u6)J%tH*Va(_<`7GJjrI5OwbXr0>`F+WuU+yljxl+m`rsz z4x);RX7PVaMBRJvplH4WZ~&mb`-iX0%+1k6o)yT|$E-2@*>!%PG#jW5l0##gAY0gm zWOPDh)dEgWMgp7y+&4@)kb?f>SuuP*a_9$9J>sN5Y8%nOz?rk9Vxj5*yPUMVfdxWO=5yN@x0IDqL}D#9C&J@th}QUE$wa=mcDwQTR}*z zX?Ndmuc_rSN`%CbkJau)gy55qkO=DL+&Zsc`=Bi|(qo_gT=fgTMXa>r2|H!mACV+@ z?(e(|q1}U6^HCy~A0R|eRk7t#ckSWWpmGnQVyXeKY=L>NGJkE&lWR1~$z?|TtUN)u zb%HQjim;kIcQjQ$b@fH19vn=#&-DduFIAH&BQppPWVEA(OOlWw5vl0u#ENGLkBJY+ zT~7}sJUXvcAcll(?f5;F-$#huo9^M_Vrge4z@`UDABjEgMsE_nfY0UCk~d<=-h2ah z)R@CEddSfPZ6F1Wb#uwtntu327{g?NLbSAgDEf<*tyvS7Y+KA95%?f4dIQamBOiMlSOp9MKgsBIRB&($P(H>O&9S+;-WS)DymrYH;I(GUIBQPW^*_F6@YpRV+ljXt z5r=r=zM7S&hSKaN64Vv=0GbNPJS3#YXehlD&Nn+x-iZ8sKP81nI4LT3g)QGybh6P< zI(7@D6lxU%eVtE(1j+r)qHco-dv5l-t=&$L>b(3KQmp#|NOA zQn1g2CIGaYSxm;0O6zjKdjws-UNeFJuJ_(6Io)E2>%cFf^y+X40VG!{xcOsTHG_X` zZ4EL!#!&{Vnc4>2?e!91ik)E%Uaybm+D#u{5JV*ApLZ5P^$op`ZBhbEvM z1-&c%9n9=jfLD(2nsx$-zdGoAN$5xV1z4NFD6$MI{D7|F)n{eLDK% zEMUXUrK}z1A#rhWUMKu4u z!2$_@$5&KkcI^^pI8|5cb^&=XOT4&1fA$rOD{VWe*d4I%GuT8Ogm&r4`7(xu>Rh6&+=NYVuH$+;}O$Q*oEsUa`Md0}qQI5P^mHziF?;UNUaAxgM`xAMqwC-G*BX$KymdrMs?{HA&~90JRetSXI3OMNQb&$F zD=+UmD>l=v42YHtb(3Fd2_7oIIDtd!;_vzB1mJ)iS{Lnr0Ek-rTl=7wKX$SlohqP$ zF;{29{8KB34t+&KH?-eUmLR&@-Lcs^R+BpQHmh4E7<(id#R2zXcs{1mdXEeme2?{n>xka#y_v*({Lp@j({%Ff*2eqgIP`gv)}6;SS|aKa zG_2|s?m12bkk*CJaYf}3x3VwpdzmqY8~flawHil(sptiUy%nMA+8of!zK!J#M17$b z6_;6NojV!j4&4}X9tju%hAB>^|Aj;yauzu;c|5iCKBCTors~dX}x3pcDPDe)#-gP=#&&D81$hLrA zTDy%@w417koy032Q~KhlClRMKqg}#G8 zFKn*Dp#jK#3xM+F@TjQI0Q-FZjQBkL27gm*aqLM^QBlD8m`x(D?YT^yY!p=Z2_qXY z<|ES5ts0}QIUcOb{Jo*<z^gi zG>RMQ=lv(%iVAR|IW>$J@)HjwR*#@ zCK`tOfByVgTxLEOmON`_Bo=UMNq|IxdNR03j+$#y&S#@M{k9dw?z0_E);a_TYHjU# zeSN(V$Lqv?(fwH`^~;Jm-LfqYHFtwT+6`m4gm9;4Nl0y?QD5lL*mpe7e($nj*Elo| zV;TG75ZM66K6Lku)oYW<8bh2ic2phA?~ZHw@$LOjduUhviMJfWqCGuHhGd!r&Se?) z^4MajPS3r&VaQ%tPrTKnF@eebh9erWj zMu%%Q&Zzo0*yn6rsR~z^3_DWfzoxs=fkW1=uF?SFm8inVn4;I`WRuSk?N?tNNCfwctzU7Jt0>va!Y)dgIRby=e=v4;E$r ze0#84_EeSc;y{o=fJzvgMR^~l&3~($@gkUFXVv}PJeCgTu88c9choN{=X6suZnu7| z{(W`u3r$}%Va!fE1RYYXYH$QV!nPee%Zy%!d0NwhEwiF`5^pqkF1i949GfKXq>@;} z05-OhgNX^#%s6I|&UiU1cIeAkxE0$Uexj9#Vmokue0R{Ioz2CUWKUnbIAB)H`6kcL z?FJSb4EA3_9<|j7 zBjY_McYARVlJ`c67}O?bMj6h(Uw-6Il+Sr?RQMpRMbeX56OT)8uC(_261#MO?Sk{C zEbeto+X|e{MOkg$KkhfA_;dqYI&h}K;b7sxrH+p`cqzIP3urx!R(=l8qGN5hLj_aX zoO^~wzBAp$P(>@@rFitZA?51t-|vzo((l~4V@{H@SBb0F6p!eYJpC_&$E#nN%jh1} zGKN+zKm9xp$FYRXRpX0Aw9xQ(F}Qq04LH+t)G@R7XxX!8fk`7s$VE@tI&R{vy2n*P z{xm>4)^Nl*(+p=KfLnR8nfdtRKTbpC1q}@iVLODGzpIvYl*!I{2^gVeIPwBs=P#O^ zTW}x}XdL7)&rM8--QK5n^UJtncLwhg|4qx8j})}K;upc8_}lMV+Re!+*4VSN2umi? z*kx_;`#C@E=E=wey!Z=67{p1znHOnKp1jT06250P+ewSN$@lM;l8;>6zTy|K@OnN{ zsbct}mK512K2i98)pa_ie`S+tLXH^J(sPrcQUfWJ2=$ohdp$5f^0CI}R!3?Fq1-7| zVU!uuZyq1&>MB7OCMzuereh`2exK7f1agDa)OAz2;4DY@NCwLUt>Qc>J8s0p3;|1a zf``=QH82+yiL+JLqMR2`eK0>N653fJz;bjV4a8trsa|cnv(c!oZfQ{${8K%?e9>FLI^dX%%Wlu^0RAU2(BdUHdZ~T zc`B)aGVGw^dp&~ zQRBQsA3dGQF2EWwN3wFvZ~EObw+bGC4TzdrS3w$!eHzxk?TNbg^>@gY)a8D?C?#*68nv>0bmDyq^ubZW0S!;S>J0pnp)Koccd3AYGB` zE~;^|$xSW50ayF-88^%%rNMlM)QLJ<=G zw^yzqNnyGM%k-U&wL(G?5GPPj-DGE4@@x(p9b$8W4R6Oo%|R|2yIt(RJ1(0LkkWHs zW`w^i%zSBRX!Yu!DpS4b$CAYqL!*4^rNepXsv%RRY!j4sY(NiTP;b38ewsiVY_=M3 z8>q|1RSX%*S-vB-5@nBSwmL4gi)r}c;38X&C_VkjFfREHW5b-Y7=4I{ubDhHr_4Lm zu!X{zDXgle^8CC5$)O^qo%H4C8jW@gslt|sz;5>?Ap~bViI%7i}#`myEA&OgRuUUkiYKU@(DPOysisL~bXWzbs z9L%ES`6Qwk2%O*V@QtlC7cRAHhy`|_N% z3}GvF+*x%lbRfhBQoS)8DrH*ij=@(?<0DZPg9^NO$zSx!7+Ykk?R4fwq1WhfhZEiN1v^xC8y_dtHThaWjeE}Nx$st2UOR~2+3RQr& zI%@+J>Y>Qw&&b#dcD}+%F3H`BW6$fBNZ<2^X$xJyy}9;5Nyc|=VHD(lP{^aOO(F6r z50T<-XL)UUAg>w+0~Lvc)qUQPhCFX6G*y2o6q#(MVksM<3k?5T*SQP>z8LJi;<;vJ z+BJoTg3RMBu7#kXVBHXs0`ZL6lTXNXe18nN^F2pf%lB(3h^{4mR39*V&#?(&Lwb1% zfxR}LvvPU4K7TaoIAC37)1?<7}mTvxxr=C_Rl5#qsfRg=5EBDz@D9xI#OX@0Y?JcU|T0X_EVqdG@|h?rZC38=vjyN(7+z)y0@6 zc#E&7@>Tw7uo%lJbrH9(wZWj?Ak8&fUC*f%W%iW;q&i;X~@cL z++L6DMjjs#QSq%?yF%7!FFn8Vse(a^VdtMLf)~1%*h`qUS`W&dWS08FoSc8(k4HqQ z-{~~g;8f9~{{0C9R4KuU?=}Mi!gFwxrN}zVD_fy>z}YmaZLr1ig(8`SSreH7)Xyo# z!qU^zr#fF1f2wp*^CwcX87f$wjNQp~*@P6q3WpE(BdG4_6ITUAHHv<#3y5XAGlrZ7|dN zA^PbJMd)t~b2?wxH+EHzP3@U2=DOk-lm4XzZocEank>@QZ?#D#qfU#St?omkpW9b? z{rm6D=%bXB;gwcNC^LlSm z5;2M!u}!f=$@bqIa1-v+y%*LOj_b7Ny-4F`CxD|!n_sBd*8^L(H;8;LyPpTiy&tCkT(HND&z97*tD zyAkaqo&N~a<=5#bEwaO9ea2z{>*F<^DlJd%)cu6y?3*X1xb8jJ&hrR*W;?@cZw1T(XW zigpSc*N24h2)8!b)V>}ITQU`@b!+K(PirF1U=)+{bcCE%XS%bhYO>mAldjtN=}4xa z@ap8Ui-4eFx2S|fywTk*PMO2~ThlJf3N`MtA-sny!w?gIS?Sj|9}jB;l z=lAVAP0G~sJu{*YQG7BtyOWLXK1c$o8%UL{cE;}QLaKhAK9`zW6QNNa>3MQSq%M1Vn}f8E zcAbGn$41Y5&>={L`t^>A(m8t;mu4nJO-Dwl4Ngb4MKmwFRF)LWjkzF}1p zQg6veGY9-_=1X#d1QnaGjwcS^e3S7FhXfjH;&gcGA^v61GB__{J2zzo0Mo>4i+de} z<4-8@5Bxk~o_YRCB%J}pE>>j@^bL;qYNTEi;6NyUVV6FEiHyZ({F*@BWi8V3Xg|MM z;0fypk>i#NWg+#_{ToqBRdAT;fkv>+~LNS`N1Rxe9N|&B$j>Dve=wp)^W4 zXivv6gX$#k0~|E>kw;t11iaagCHR&~o8iodCs8pK(PRX3Kp21HISGLlAfc?nV|7>s z79M*tU~VdQrAz4u5*Z+}p`sVAB|;E{l^B3YuF*GM}>ke~^r!U}N`!P2s@L-Bv2rDzJ(Ds-rgm(l5 z2eXOKT|qEe&hQrNvEo;OUsfuu3!flOXSvcYH8mBUz&iV`pJwy^Qj{8MH#!|JUhJ>& zxR$?1+YbHxfZ&~0^wnHmn%~fe1v#8=dGR@!@bpTAjuu030>A8-vhblq3E;+OP#%QN zXlt(xR$b3S(>zl-00q;B0^=H;q{0D%!4(Kgv%Va4G|_4JI5b3H2=VlT{z?7&z2mdK8{-ayCgO;J$p=I_stO9RDo-S zF@LXdx@H!_S*~?kwiJ3%FmSZQ0aH9+RcpSM?SB0_tl*~Gr|LAF*BPX{?-E3Di7uD( z+m1h1Fm$NA46#?xjmSvHeb5!gWR2I$RoJ&iSx_!b!Po14b zg-@Bi`e|@{0;aEaLNt=0G+4kNkOM%rl+$NWa`l2+`4x&|vK0^;jQPI0J#`aNnGD8r z$KM5C*S;YAOgHFLrMZ;w_*Y@Vu7E{ZKgEFk(rJaB-cFw?&dSk^bYLJFcs{#*;V*`W z^Oe>hyCKT;Wcm5&#W}0Xg)z8!;LD?u2u$}qz2mtIFYn&o0)-xm2;t`YqGm?&oz=8xxrn?hXA{T+x28yJ zwY9d@%8su<j`thaV+}2ie>sCJfhXw4J`EVd`>_dOWB6l*4u-3Ag!H{I(pDl46fzT#say8S^ ztc>=J7AhO%3n)+SpKxY8ar@j8&&OYOth;uc1#-qLc&D9<0ZNdM4#^Se%z)|0a}rv}rvv~~`c z5f;a6nvr3aA?#D*oJpr^H3vaGQn~nUaj*Q9y?gg^|Cw1PX|g~I=|7pxAG5@IA$^8_ zkgeM0AOlNXwzC)OOZYV;*UDjV)E+gUbrVbW+Y$XPMd#yg9|3b8z$4u@PP!3Vv5Iw- zZmX3OT3NZdg7VQzoI6jR>;iI^sdXoz`$k1dQ%JoD))HdvAm4&td!MblN3H zPmVupg~WpwAlyBF=$?FK+`(Q~nfUN45A3c>m+p@xO`Yg@hC?5!Xi zZP!13R9HB?1CpGtb@27QAXuh<7BQ~!kj39N(j%S8r zW)J$GItii3>el*oir?{Lqtezd{U9@LzB%oOgZ||N!`!e)ZBvy*Xgle%I7O; z2C>UjMj}*ITmg{4fS0q()iMG$z2^aoM?9bq=++2vpP%h}%~No`ulDA+U~ds*YW$(l zvT0UTVY!CAiOB>;qLs%)NxGt^%Z0=nz}r>c7+krZ%2LeuP-m^~k?(x@ZM@^$ z!##dAHAmB`msUeANIIaOr~(S98#F~;ZG;3m2;uwjPNEQ4Rk^OC8F{0~o!uO`@hXtV ztBRBN9<|epH)T;}4ZHLAMDPpzl9F+;gX|eqlkJgWc_7fxxsf{ZR*}X`o|p1iH*66| zwqm1%geWo>>(9PO6_>mqC2#obVlal?b0JR^R6qMD~ zJ(N8~_T+s3V-|bcsh0cq@Bg0uRplIHn5jx?KHGf(FhEW9H&sfALrsNvu;kir@iw9w z@^?t~z|an2>5+JhAJoTI0B>LahVb}st$ELrQb}~LyxbWA5Rr?VlI8yeEioPo%_^0$ zo@Z2vzx;IBVO9Z#;5-85HbQ08m;3PdBjuNvE$JfiL4UDxCM2lZD)WKH0izPQBMv*S zU%pg!U@)j@E)5HuZS;pZAR_DP4Vc;{4qR|iw>@P@Az~(A#;tz$TEoM|-&aV)cV1F` ztHPC;=~xs1k381fMmKCfN5_Pojh-kq#zrRox_{Dx@GiA@3Pzsy&cdAz@}6Q90Ycm(PJq-iCAgUpxJfpB6B=l_pLXNZQ@hKW4g7D z@mjP4oB|s6Qd7H~d7x{o22##I0)diacBq+g} zA@Vy-c9a;KqOpOQAWK73hEarB?T%V$8{#HU7?_W-FfYo})6_0vGiA8205;5|!BAXU zS~?JH-w(-^U~mF>|KwXQfs8993QWhm({P_QBOI~jY!2Q`Brc0t6TmF$_|pOR4QMOy?o5VV6*dloQ1+^8L}P_h za&;>jkjh4St}5pbVWZk%*Gbm{ryk1=g^an;697qxP4y!b#LtW($SZ9bgfpJOeQc~) zQ1Q6XGEN$5JD6L>AmL)YwD%7(JaL=PYRY$*5lpWI7GBK_GjEY4OKZB!jpKoF2M_DMjv!`>Qy{<)IoH>?$wI*RQASDYSW_~E@_VV=@t zmo)75I`YuV|BE4|Y>3e5TmT9gWsCcs?m-25c5T}6rm;bf@9%1QRJBF$dAPd24W@DI zOrkm+bD$i^SFUYIbxlnXCp$Mc{b&aC#()63aFHT}WI`$yzG91F1XA8zBjR2P)V-^u zmOVah9Ja3{p_yR}5(R z#V8pc&En9RG{kyIw!gPmb?}0j)8mkEuYb3FYRHk0kPyOA*(?Ndjf`^c+2vH8N02G9 zZE|I7pPz6xeODMp=A+_akiT^?$ORtAPS~>H^G;V_wBur#_m9Zz|Vk~p1V(L8ReNi+g?~y{+9eu~_gI1wg2_q{j#1Kcu zA||fgy38*mln-ua$%qGFqtoT6drA%ai_HYiAYyB6EeI~oDRDi1Q`*ttYk!KAVfZIl zFByb`vYG9AKYiNtrCLq=g)CH@vb`*cIY%nl)^!&3>E>6zu zETc#4%8S8V1cxC8RP#n4aQ^PmO^n=mx*o;LHc*(t{pN%V0}Lb#2HEwGH0`=tT0TI? zXd#lUYB78%OC~-cLH&}fygZ7H@uxS8iOLY5WiZPfJvu%I*t~UeR_M*sr`?Ugc%q$} zySlrdLK9kDSqWRllm%%A+P%yv9!^;~Io^vnq?%Fe{+Vn4Ked|KG3T$!?eGAt>>Fm!vz^5qA98&({~M0@RP7c@)J9}ffTL0tV~tj;C6=m zPABB-a`Q#1E3)!bU@OoM<%ewvr#fiRKgHcoypSkj>iE)cC;UrTKhb)6p)sk9d8$dq zX~1C8T@zcV{%7-$?jYp&LFI-hBUa8WI3`aZK=VBp(m4M}T4E$5dob}TFaxNF*R5T5 zS#(wZXTAf>L8SQ;&w6R5;uT&I5dvt18iv$ZSvLk`^03$OA<^&$v~a7xex0dw<{k51 zY}xhngAFCYabT1iG2NM@XbFwfVA*;@>qw&)p4;F*X_>av96P z9f&Iel|t17%jx!)4cmXwPSOg}-L&vr zdw_S5*C$K|u@91y1bXd2J^- z$MAo2NE;pUxGH3PNT{25o*ry!I^;b^#cyJ8%*aRoRksG`h5bA`$Q#vn$-N3GDiSR= z+0JE_}J8&;L_NnMLGWHUS5xRW~jQl#y!t%!7=N(n2Ovu%Ou zay_{#%bryz`^gmGoLHyRO0i^5w3b_p-T8_R6p5JSM4{;YHH~U^q3l>}(MlFrDo{S+ z6qHZ!fZ=38o%>}hZ%g^EG;(^>p6PR58hEM#;0hOzSZ=bL(uk>!SYUomYcd_L#fg2t zN&abznaRobhsWv(Zr=VngdD4V`!qXDdN;nYB~X_O=H59F-SlDqA%w{Ze<%6fQ1L)5(+cInEJ~uL_&awC+<$A2FIxwNgS#?CXv%ZkWp)-~yQRid-A~H>=9FR!dLYF&{IAWHIO+j%ZcuK(I~$<&_WIJXG5Dqr(U#5O^8A-;)u{=y}~mSc!E{r!(108Zw{ zoEcyDhY#+!_W|i+tO`ga=ur?{mDGpC>7_2E2WW}(Qx|>=ls3U%mf(TU(dKhyiS@Qx zA+TaE%n7Wcpp9{}rGtg!R{Ck2sk)A!PU<`Rp~IwcM>?dMf#%_>mh{6a>*^36jcZ^6 zJ~OqidmoPsg4ARc6p#y^8LO)P28n5K{d~r<#Y!hLvKk&E>ul^F!PM(t$i&W0am)dq zA|E{*7nr6_dwP=eMWAo~J=LRD*UV#&m;jH3uPPK(w^n1u?60h|U`;M$^9-K`*p+-0 ztZoRAIOyR6cppDh({eY!PQkH2K&^@XmEN31D5jwOyEgzK=WQhQA8161S#Qa?bg)F^q{o_1 zrY_!5I*bYApuGG|$h06-Pf?JYJg|WFyDRO_lNT>mAuC7Qe-P3#s4FN|SB~YD$us?K zD49QgT!(G&_riih|6^!T6Pkk<^T}|`Tg7>6_&QE2SfsyhpD>hfqRIB~nDpXa5Vfgp_?fuEk&>_PXRN;d$>geF$V8`qQlodkz z&t<%i@e4NS;FOQq1J+Z1={|V9w)Jz`QIBHupODS_>nsrjC_RY8?7$)r6gV1!Bl37s zv-;$5a$(w&nV9bvt%Jf}^9V2BKfng_G)UFU3ZBR!;XtdGn zLNcPQBZ2J1Sk-0j63s0nU0x^=uT-{t6!RGcl_2IYJb?=nT5n&Bzt~l{kI)676DOEt zouv=(&ImgFSjLY&kLwXJ%k9f21cYmt*&u>HIh-F8B*%q@);? zKny`bH#I+hN3HlAy&n-DH$e&+wl99{lMPNkhqRsfhr&Y;LIM4L%zq0lo2WsCU+H3v zui_Zgm)P;4w?=Ywq7OLtNvKob-v5B-RIOOOvVw`3JESv7G>R#gLB$^}8h#H-GX%+PVp9Tilr~95udVdL|6Y7VmlC1WfcC*w(XtEczwXjom@Fcu_(LN zgG;xqS^Xq%vHpH|AH87d0$8+(B5(u7P_M1E(p;TfZ4s1O;IN@kAoL}`)N|x&s(`8@1Aoe$1N;;o8Hr^P4{~#Ju~-0w4*w8R3ob-K!iOfe2kT~%iO=#YDyrlc$?MSU z_xZJtlQfu5b-fR2!XTt-;yr?tR0W%ZBIsAkcT1fQis>V8b+_^S;ZBE28ZQSP*?`s@ z{uk|z5IM)0+OZQM%mR8XNoRDmldPJ^rlra2{%3+`Sc*YajpkOmx-w&m_L_>0uAl7( z#PQu?=oW~62jk%A;h`Xla(%E zrI4JO>b&`vN7y$F zvqI^*f`B^L<;#~#1q4h}Q;lkaglg&xUiJ0CzhgMwOnc_cnG``R+nA~0i3_{4B!Z~P zh&`un>ykCnO5d&e5)#_)XZL|CdrDl&L7wB84OaTRQr+%r)?@hdP>}Z_Hc?J8X;R6H zL^8xP{vR+j^WSx>#G#t9yaHO*j*j;&60}^aWgGw7b!sP#mLQfZ?jk9+0L&w_5DQUX zv%^`=d6@0L3kpVdfk;@SW1$}q`2MdIo^W+hNU8sCC@1^};XVkPnjc+DXfr36 z4-pos!usaeLCHM-|7?b3=llPe>i>Dh2wxuPSMd^OvQ33g`L zD2zhlzkhcn&9`O5(ky2@L~Y(VcEU&M(A$%;-l~7^v8vFYY|{cVg|5Tb(C-y;UIP7WsFn-mJ_qBv_bxe2n(!1smR6V^OOi6>(U zlr#77+5aA92ze6A>H3}?xqbUgBs5(I;oa3U$Ljt+x8ZL2Zc4TzN0vDKw*P&!M=3sD zQWUY&uukchZVrEP_#I{B#JfYD@~krdw{?V@y%U3k+rFF8Fy#*)%L=iSkY#%B{M@$P zk990xLz!s2{S7>A5sw@aJvKHL8{33(rGv3ZGcKdAFBsFJ$57zF_zSapqm?&q+`!R@ z>J#BUf1h89|MKbUPddf~EXa7o=jK2AezM7z<$Jkrx((S(q^ge>XLr+lV@jOYw#Co<15!rVl#aT%Wcx)XOIM~&<)>5DRAhc zV|$Z{+w&N&NJQS|++#a}Z>3=G2a%@6#m~Et-UEvf3YB)XJ z_VD3rYir#QlhN$nEi&qAvv9oBb#u2-nLF+=c#8c6=bT;A1ij4~d}nD} zn{VzXSaf6d#;nZ!k3}~?-Y2(#8trvp=8=G66#)1+9gF%hm7*^@3rk9J@<|7W;8V~2 zer#Q7uY^G*-vE( z;Fpzo1<2D`z}i5X?#c}+EMe{nny^@jM1nqy-_UpBvv)_+rf6$(%33{6ty0l#gZtY3 zY@qfbgT9?$m73Pq*9TR25qO2_wWVW0K)^P6HX!Cfal@mWr1eP0O{u2=y;A2s6Vk~- zsn~%C@n)0DN=hHeMFf+#fJX0*k?Wkdhnmp`zcow$g$n7pmdnX2O#iTe>o0Ka?|&aU zI13*cVS;`Vzzp8BkwZ2&5+Lr|S9Je=iZdA>uXe&^-WbkOJVcvK&M$8S)YTPh^Ds97 z^RGa97Xs`0s{F{c9Kgwtq5044>`np#gBhm8%^%AE59Cp zXlZFFz$kgV7nOQu-E@3WX;RJ-FGjLrT4NMn2diIg6~W{y)Z?*l;K5E~o+uFxG(_HS zNox7n)j|obtJ>Xs*KWzU*}*jcbGpoo44l-}aPIpBXy!z@I$4)tcWjO8e$2T{!MKra z-WFm+pb;roGhv7FC4(l+6AxqjG<$8fW{CgN+}=IC2jJcHPFG~8A0 z%Skm2jh1|MVd1g!8=H=7{PO(ORDoC(V8g;L$IOyJM9qJ4adJKYz1TTWb--yD6*1HT z<=GHsD;Y7hRR4w9v>$E~A%VP&L4-IxYzd6&UI^_%(|}UZ1avoG0!+KtYCkr8EHZ?t zlT}DBZF6_BupE7C^$4%3m7&24zx!Ek0tc)2pm8icB60`1qLN8YAg<*?l(hB!*!Rad4Gj$gd-6%Ljf+nffX{zva=oUnuL@QYfGffxBIGXqU~WBP zv{3RLI0zbRwOjB!L7>wP#-yy|RYL&I5)Rs-p`mbM*O3)S{?7bFg>FG0Pwx~?u|KXCzCw_VZ-Uh%v;V?l#NqI!;5p)iC zpL;62CG&|Tu4I|%BK|J`+ll%y`3OfF2M2QuTENR{$V1RNsLew)IHF~T-Laryr#vCm zmDR_!_PJ&S9q5YHND8C31^jkwofknP4|gaAe(w0Xst<(@-(gpbWANJ%cLRbMotwM+ z3rcsGN2YV065H}f6sMXB7l~#O%%B+S$(B^u$Dlh|UimN+CkPI8vNZ6>rZ1W{_oQdIB(uRdTNPeX;YA z{m(4S-*S21JdO#u)GBhKNwMB%40xdP%8Dn*61Ew+c&;5$$+am`QNtDf%3g z(K+K64g3YQd7=qtT8QtpL(L73XxU>9@K4Ns7dto)toQAEarca$)CVWgY;#vxZY?-M zs0*8$uAV;Cp{K0;8D%{B#HXOjM_nZ)j|d5o{~#CyUSQjCb^EsFge+73`LVYEb>Q z({JxyA<-!0R;LI}bRX~F6%aCytJAh!BYnedcdX#O`by`w>@9XzFi({p)!c@ubTyV* zo1Mks&;n%ezm0;a;=t%p10!F?O^v)7FK>T(WY_5FPi@nQWkb8o$=-e>$@*H{@szt5 zZCfSFTmm^vt$<<9YgmK{tj&X9Wg_XP7!}dSZpoD5AG6hLK0#l|e?IHrr8!|HrX+ZL zjUd$IbE%u)H7W>V_;i_LzFq$5`ThObphJ9@yFyzNi@Ui~H`j6Aw=BQ7>($n?pqo~V z-g8$tHk-)jF}rK!X(%=R0yjQawCNMRE%mn-cvbEmskuvCZm!zG5T&yKGD-LBt*vZ9uek4LcNR2BvcxRWKgDyqmSNx)=X-r6lwc5`k&RWVHr*R z6W;^MqRSUKjNZLplU7jo_^crq6IWBSY22^;=wq4a`QU49rN{{tIKsHo`T4GdvLX%eY)Kz-%8ZiSq+P*k=z;gy6rjkmZp_1;nIaBoj@?XhZe8~wo6$Yj9(D2 z-Z(Z?X=&p*oN8_$1YsFL#O+9jswhiI2_GAU0`8J>;QI@k$M|ZEs{+=qBwWN!CaAx} z4^9+HI6zTP{E%ddK(^;c#eP76A?G&4BObJqntEZj`#K^$86sJcg*x|R(X>^QuO#!yA2iqoyO7M^TJ7n_cL@&%pX}~ z2kn~&Aiv~d#BCMH7Ni~yS{;l=Ywr?U?b-NrwD6(P+N$|jUA94tp7mi>zZO8|t4Q1;v zj;x@#sC`kV39*hoWc>PUTwm^ha{_|=nwlKafOjUUVp)E^htWnW85MhzSh*XOMxX!* z_udXN4)W)AO#Ty`vK@FMcpcZP?`{jgmh-l0?}O^~F3g@Nu?Rz4pjv}l!SNM8r~Xny zye`?untHQ}>6C$XO7hjs#Gl2&vumJl zL^GU2eyABz#(Ux`Z7J`74KYk6LMrsWy4UnFW$|&E?T?8*)0R3HTuEXnru|bulcIno z8EdoQhvCW~{0fXDrxmR_UujxozDy_q)6kUlKij=GKeY zvImc~e<~OAv7R2eNMT<4L)h%CPH8>Ut|F?-&jAAbWBMW9S{B zZpx+#%WyaS#;z!{VCd>97PW%$LY+{~}3@&~gNc=ziN$`^4nG5(0Y>S?<{obu=@ z8=FpFaAU%Z7&7OvEAt-2EAHcKG_{_yyT*87`sHJ>QvfwjQ(WFpz%)~C*sa4|XL_^P z`j4OedgHH7IXxEY%QTZV&~kXZa3<8u`tIIfAh~s43`spMUNl;~ETa77P1=6w*C_<5 zeP)e(U#f3MxO40IHOSRRt%NA{IXQhjIC({G>qoVYt01JXK=iXNue+1MS8n?bjJE6x z9EH{82oN#U`Dgno7NN^ZhzVxgBt*Yg$ z?_&>5uBP&tzQ<0BzeT;J;H^e$(&NjD@S^GN_I2|dCOuMolIG*QpocjBfs+LwkmxwS zHD6@3xckfTZszJ~->5P5H%(zU*)<%C)0YXydA!FVpdFUhe;UHwHcwiL)a)TJL?7IY zPT=e8>Er&Jw{CR-;YuHp@>vMJg((N-HJC%kX6oH*sGlXDjD<3A*Eq+tBQXeCOz_5{ zNXI!r=)2FH5&l6L_4&)|+sjw=m}x3Jo0rzFlP4%Hm;p~imM3OaQrZT*FX1RZ_hD{+y;@ex11An0Mct?lE{ zk7P2p6;60zDTDjaXo;l9go{WHN1I`s_=@7)8t_;cE+W`7`5kCXsl!f%AO|_58)43N zuVtx$)wxU=DdOJQ+#mK0FJBU%J#+a9e$ni>U|K)Rh}MOrI~WH&AiRRtHT`PyAox2< z5|V`5rxm=Xd60a>+$8~eN=j1l>V@dag>Z?fxj7SE{ccNDeqFXL;d)k%N1@)96`&`u zgCox5J|>>`I25M1wQ2WXSs1&3vwZWF(l6uV-k3(zN{>_`!_I_#kmkAkcA?D7Rh`t` z+&vSSQt3ad-ri<$n5o#MxeZ`ditZg*!VwtDM%3MzbrXQ6*pA;{E+nl}dx0wj`D6=A zT|*I(e7PO#zuzdLW2b(Ef^cjMTpkqg;n+2)cI>!eMp#umLkthF8(U4Zw~D_j?21v&>)kmx z4nQ7z8B=(D4P!XB;vc;W-#)RDYWo&Dv*dVXU2#dtL?_>{R*TYKNnC0b5V#6$sjpME zodd8xVAeZphNw`mB3$)PEC?0bxKgY3U8ivUuI5i%mH~c5i9?f8F<6F7-^v5R)8vEBzq51!%8|!rJkPfE1Y0z!&-1XCX_=M^w zzXZPGUM4w-%&4_zTU$6#F4YHe5cWzfNwHrqq80&Q(L#-KeQSG6=-vY0)IfK?DX^(e zqqF_lSGjYB=7aNsH`IW8kM;S*js~nR@8Vl}XkG+|b$r$Ph(TecTSVlTtp%hc4b9EW zcCXN4i3!4+B{IP_SWuxpg^il}iR+*;;p>KkiFPK4S}WypisfJoh$vC@N5@%~eDk6b zFdt%VpW%IN$vN%W@Ar6`lY+?PzL7UP+<|Z#Bqa1U9{2D0hXpVSn-_XOvkSFKIZA#) zXocxs>a!3^k4s2E6#Dm(k3>+@B?+5%WNJ{^GpN@Q1ajU%x5aELvYz}VlzX0& z3dSiU8Y%0)>SJ&V>z|%@xJ)qMIdq((2NNGCPk2B7T%8P9KQeU|7F!_}H!(T!;)7cs z*o^c(OesP8!eg0m&8Oi$s-bRJ(I>o_8dd;MaYKQF%%%Kl!$FcOJE+PfP-zD-r*pZd zd)M=&NjQ*2kSN2t7y;E?)r8ZKm7kTIu`TpAMY&&XV4BDNS!{qR2W~3(vBs;V<{G$6 z)@?*a6Ou^Z>66DA`}(dtuFhW`KN$*yFWr>6>`B>Zvy6Z3mMnaQBjxz4dmo1N|KPwP)7RNv&po|Ech zir>AzG^^?7T}9u1XKp$jK0-d$VA}?S6gvavF-(y;R7pw6IbMxOELob>CEkwoa@O`K zvd;QMzl;7}36zSqvXL>%+RmF(<0eQ9$)qMaOnl@zbZ0&8(>^%FOMUcV4vmOG8P~4a z+()Cn%m(Qx4t<$n_Dqs;mybT2ihs%wSF#X4#7*m*m(Zs6?9**wwPW1fbIdKJ5?sz@ zqCBe;GOI4zizIc!LIRZp4 zr(kH?%zOR3?d^Lz8GCcCfTwW%@51a#u>|+gBC2C}7-tLb)~!iVp;Xn-09wS7@bPM7BkyqC1r5oX_?9vPvaenL;X|@o(!2Je-IOf z9?f|-fz6MM*u!F-oIFzh!%r>|N~W-v4d5tdWg8CtWkXuka=yB6Wjwx*XVhXsj`}5t+`L7k9?yfQ`7+OFQZ%M+%&%FdEp=a1IeO@3; z>OL~E)49R z+vvM|aFaH!#OPimH{g?V-TCsWv8eU(egs-_&3(Im4V5jIOV5lcOpq~@JMs&NFTRz@ z+Q+*}tI(G#$+IZU69z~)Q1;e3*}ACo8%afK!Cb62@?Fp{X;^7!d$ zvE@di0W~W; z!#0Mrsd@hyi-R@<9~j&6^3>fBRG$f>R7ipPfVTC(+`ZJW;9xa~yg4Fm2*(_nwFk$` zZzNot=&R)32dC5&7_a;fc{NX15PSh88p0_wftt{NHbRbbx2c|aHv_=Ez4^vfoh(Niu=P2zetX^ z5CeD5^X#MMKh4{dd%XO0%k?Tqa2OSLvHc*R0#9tNU}zssI2cR9dr#WS1Hc~^w>PM= zx{q!wSp0{oe(61RKFOr6L(6YV_g2n#30fBC{V=L+X}OQ-TmYEoq**+F#fNA*H z*gdEu61V#K`9ag_Y-h&?#~+kUX?}Br6uw)x*f6Zk(X{yeaR6l2RVUk(H{yP$pack7DUvhj^7VPR0VJky45 zgfviZ9)}Z{T|7zkXD?T#U_tiNrAy0LshWS>v9G5H#+gZTJ6;Pr>yS_{nE}80sp2Je zp!~T}gdbXhnJl(XfrH+JMc;5&3{+~`d7CHpsWQ_>SC&djWC(BC;usGP4_xG7^SHrx ziHnKJVVmZrAx;_Ju&w8mjVvvd5!uIwPg7infWZHe`afaMT~m7efsJ2ZQ!^F@yKvRM zzofPYIOFK(kGzDslY+Qn{_NSa-yQ*h7Lc&b&6*n`fXz0Jj*JWp!8kEbqm2lq;qh_g#lIp`yxpKojliK^T_coP^i=wI#*5 ziLD9|rv|qyWX)TV3J`4x>f=nGw^E+0ysDs-8o{;2ggTB-Pwk0N7=2#7)MJ4O-$`CEinMF^!Jc?__4y{PUG&J{wdj zBOdc5^R-x!*5+n0DXE08jeo|<(tU!pZy4XG%w0;yJ8_WuF$YZ|D+|l`jT!Oto|c1oODMOdN}lO_Vm%FTfC1|fZp4Ft&E&sGid+cfUB?ggg?{+3o%hmL zTE;sVlY>2AxQ7|EP9`Sz5T$FbzdwBAPp=)zHT(O=6J2G7zJHIj&wBfejiK0CP2$2g zW7t^I=f}ml`TO_5OA>vRiE#bT}0gOX(*=7 zoy-6G6!hN!+8%7K4=pfaF|G5vM!(aS{~3S#z_WgTM6-PhBBf&#vGjr}YJdN&uR}u* zy&2il@-SW>8&-VPQc_?%uB=R!{g}$eZ=0boNKsBCV|Y;5cZP`K%$Xlq@z-zMxR+xp zc6p1DH+dPHmY5>WZrTF%uNsH@_xF464@~=my)wnNva-6W1}{YwLX1341o9KQx>49) z#GzAQgm_7LdT3}UJ~fpQ=i!*W-5_@P+39IAlCj~z!IXrAg!p)_zQU3c9D<$*f7mIN zyFQ|o$2Mb}|6>>R+h>?1x^aV1TzpUQqGC0?RiVk05)xVl0Apv@;0PriV3TtA zcQXc#>O9|GYpbnYX#CB=$?1fmg_)UM+Ly0ib^hG5tX;=xJ!ZGxcn5>(&O|})%H@gj+FDb5kuCrNfTL~Ig||yy9D6%4)Tr|z7vnv{ zbTDHQTkA5lhKad_jSa_+1Q?b?1nbD%dlWC7F&4HJuR-<|?=0kY=TZM^el&o2TBtQ!cT??9k8<+s@^Ix9KYLlTCbl zeA>j1G^60>TpPPM$Co+Ah}c=~KB?r5vKHA!>;V3j_CdKpoM|Wy-{+6s2WHp%AYJ41nR{sHCu~ zFziQKt1U(Mqhp>Z#Z2>wPAv31eIS<{l_2{;!`wUtkk0$}@1cDS({!asIJ3Xz&jWS1 z4WC%B%AA59)YWrUa+L{`%JR9OHPd2Y{N~}C8c0m>wsCVG5!7T;{@g3{ zex~?s^FJ)${=1&WM!=pg;*A%2sag3TkcqII1(Wo7pcXSRaHsA zUsdP#SY{M%vL0_}Ao6X|(|Z+rnJfH+2G5_%X*Gy>-O}>9x!G%_^q_}CM#e~e9Eutl z8JRrK3c)^1hNdcedmq(?kV{)zIq|}mHWmd1h1%L$ydapYv3zWGe0E$~AFs^4gJ+zb zgE!-lU;N$Q`sNKeX_^1J|HIPl+wD%ULq_o6bhijD5i<18u$qJTQ0esdz;ZEI(Tt8_ zZTHvQy(k92Zp>bsX)uG6pV`LlJ#i3luyI)&_3PO3Dg}U6Dz|_T8N>7w`F|BV2JxS1ow=6v%p>5Om{Mw0yuIHk_7zxRt1j=&X2#_ z!#_r(&c`e7?&0wSLtbr$)&73=LUu!!FJFe{2xW^cobgK?otQi{-M*Wg#5;kK9tCc} zE%*xxTNIN>BE0|}*Utd}C%0of=Vt7kJ0gFNQ$vA!Uk3;GCbG42J_sSjW?*>cWn3_M z|09&@#&6G`dhzphW5vH78`SO<5;{HE=LanEI(=`d?rphjOc^Eu3-oMwBNX*N2O*3MrlXk@$8itUN5KLhr-QrseJ*pWs=D3?TbG#*< z6cj+FXz2a&^JmEUMgW6Kigdv*qghu_DPX{on{!=UE*hN~_f)b%uo+`>PC zD%uKcaST0QNyfMQt6Gdh5?n(cwhl4y{P_%5hS9^I1NOXs|4s1N|93SF1uvHoN)IV% zX-R2mX(_3WZl`m9DwLUZR5I@Fg_2}hUq?nXN6G7HG6Kyop8Mj%2cGgnht<{js^3!`;`(*=q@1vzL6ULIijf~Xb|5GXile_DX5iD`+XZSt9{U)n(6*s*5Fopk$ssayor7k8k!m`tgJmfJ=r-qMVJ2E`3$Gat;QA> ztb!)FR$2~h_-lsH`k~P}Bl)LFoM|)2R&H$V=}{LPCKP4L`RIBgCZGJ-=v3cqW`J7o zdSRaz;kvkv94SIL!QVId&dxm3Tzf4C7W`JVd-v{*j)#B#^JD9re+$46?yN`(%IFWD z{?ws{;fH3)5{2&z3;mXFrNsoUpPxcj$i}tgs^0xm{}qh>zo=P%28VL{EfJxK*8cm2 zRkJ%H{VepLqnQ$|i$he=&#&%oZu`U+yXoSGhlcO~vY0ZFQ;a?Su(o#mpA$GtbH1X+ zwV}Iv{$o!R-n6cF?+8xryNj^10(#cr%`)N@g;pJhD+NZn4_s_R^WN~1V9V&zufW4YG^`QDyc-XX`fZL%=p2MW zgM)+9mdOv{O97A`&H~rM!kXW_ars!-h)K97d{A?u&;`C__5(mRRv1s?E_rDFzjb6w zGDbd=kd$oHV49@?#NfBQ4OXM=i21yE1KV62PfBX)y(}J`?BvA63+n12fA21D`i$vT z=}Vlu3YV7F9=r-Wsm8T-#9QZ57!SNt1ggQ7o`bH2xgUHCV0B(T1s^yrf}+MiD%ZXH z*41l>*(t0^&4PrV5z06TXPxalF`wW+hF&F!#wOQkIcd;$WcMQ zx;Q%K4{}3wg}OyN<2s~;va+(TQzXex{M$VQk7!p(#4M=PQ%Vygjl~0#laokE4@o9HYqdX!OgM@XbN2K0d@-QIVOOf5Z*55K+?Cr?PFmzUTgQa%ZP8 z7C9w*TvF2fi=8eQKLbB=4}XZ9Os)W-1OLwH)&$xe8VSQx+qY|sYAl{gi=r3YyI0T1 zgPfLWo_Z@zLbTm6t!rXm*ooOKvn53LrYK3FP|0^6ohUYo_4D%zu%xSdv$YJ z-aG!D?GlD*QJUyNmkHh(hZjL&{Wg6yibZnD#Lh0`!D-^{+qXxVu6-heN}*TjEu-_F zKW7Xa464Ez)X!4Bs+jSFVtDHHfl02%c%9T4xoO#OO%hE=TkGtUI+AW_Vj1VgF#w%L z^Xu2|*T&r)9UT{zt*%9m@?I*bJfx~RLt7D*^WbxZx5~{u3yh~{zexjDIu6e*=raJz z<(&O=F*T?EiS017w5SF`gb;Qaj&Yc#S+XdQusg`hE8Ry4v5ySLpOF#7aRmk5!_l(n z2V&Uw_|0}Db>|0brj~r?n@-@>VHDVHbRATTl7>D~Kp-j+*9gk=TLi z_l(P_Q>O}w#*_;x?B6_L!aiuVL!OGtWxSC(=8=-{^vWysguxD|5pK-A8)gM)>+S9y z(dq>?p0LJ*mTJn=r%&gclo8_up*?P@uW>X5vHPS|v2jFMS=ossEr1dW^$`iyIjo8q zj@PPtQjdwCtQ*un_$jDLrsoIoMokbPZBWGIHUIGBUZcX6u&h$+FZb^?5tGf@6Lq|k zB-2wLxSvlmIJpFkQ*snFE+a^X1n10i#?3aDqNAdo{8ZDs{LJgwk4TdrRvcVhJ}Fjb zWTuxV5AbmHLYR@+H!ezJC}59gyeK%9o8NB2mzPAtU~Z6#N4> z@7(tg!hMo8m+!6Zd7`puhjCK0nyy;kS3^_fBit zvna0osz=Rk$$Zhx4Uc7u&|WDcLtGi{EuIto!O(8YVYhUU$c;Kdd>Crd1czDbJ4k7pRtX58U;j~`(Q8cPa7i$m{(l__Z74^sGPlInc*iqfqf){>adQdsqn?L!g0Iu!X7uoqBsw5!60TLH?; zx(-|p3R*x9r=teKXB_}K7EU(XH4LY0CSO^dzip(XpC9?l9r{y<>RVsE!e00jbMsit zEr7*F$Gabz?_y`K_Wr#eN4mQX2me1Tz`%SBEB2m#+C^mK_4|Li5}S*rj`=qXNVgHq zB%aT>d|3fL|5!|l;94XSFiwL*8~&bx&_~B-va`geq7UpXpI?D7QL_d_@EEv`fzKJ- z#l__1cNy+5+2;Kg#>>0dd>Lq3Fcxfm>1TkO8LD9>2B8b#U+ z0hnv$2Cw!WdV*2$uWzg&z)PEEwx@QfTHJPu7#_}gT3WTtBjnicdkaT*+LJXOu{&|1 zF##{1``ydVFrmT($4!(aRVSJz5nhB_{p$5=^Qx7iH2)=1I{1K)(g7uShH@#jo~Bc4 z$L@n4Ak#55HC-&iqe!`RD~gvR5AUPW!^;Nh6&I#Qv_v0kqvC4hdpQoBXdP0A3;1V8 z_n&?bXzjG5Qap zCPBFcuYq9l^@&R2^NkIkRSrw}%#7iS;xHyZFq9diz-XumxiqXvtJao;6cq!|ABtkn zA%50_NgAbP^H^uDNrDfpqc>eja`nsXTjH@r1qb&!Th&+xaYKUNFxdi`ShmqU zIJ%RlB7akKnnwJtpF*G=gjR^M($7lD?PTNwiXIS*#eZI)c-;{7JWl%uQO2YisIbR} zhNf}Wt4VO#J2}B72>E7jR#sN1iNfOg{pKsD_sWJbi@jp9euzSwv@Q-_DM(e(sc^8f zLp7O}loUF!X_oZ945kBqT=_kJM;-@-*K;wWcZ%83lZIaqdoD!!=3uA?C{>3dC)ASV>t(>QOe^!)6_R_L6=j$6s4d*eEdXie>B&Ng$3idrq2kQed{b}x^{_` zXgfAGY;k#?&u>Rvrr9Wq7xC~lH%`+aZh0RMjabf!`&R^y=E2pF*pvxA5s6=w*SM%O zR8{Gpy6)V06VvO2hUDW%^Ri6y(ZOTSjNiO;(^|w!JbkYPiNa9#*k{|!MbEsZ?8+ncb@)iGJ6=T#}f;@7wc5ebneAu2h2WbZfZwp5F(o97k;YQeEZt{5Xna*TB4Sv9M1;oCkN3W94kIK zF*a6ws!MRZ@rZtKaZ5N^a3WzarsO5YlVSb}bqTH<2FX^csv{UEQVr0>BMOi91Lf6& z#;ml|YvlDpBVEyHbG~oE=ABF6;sb|9*j{&D_G*PPDne1)fOOU zjLYyace%Vz;T=F>sKdwPl|8b6X?D# zJ^p4hIz3*sV^oP#8F9p~PmhYDiV}Q>Mu-2NfS1Izw6y-OX^+8^txuFs*4Iyl9eE2J z8=J3+;9)DPzKPz_PT9>}F#`hw5McF|o!{PlAv;jgF%X-{;Wm0yKkQi7g zqhd_gc|p1a9vvJ(wbL7R48YJo(us|4OPzf_ZGZ2czLLRUNWEe3%;EWAF69 zKf|&UN5|^oS8LP*S5Dr??nH2;egEha_MQDOlAviXioZ@XN><$}FWs!#V6WfR9U{@$ zhu!nyuK`XSok&3S%>sfFfv9J=*vc*l(Tk$pHyC89PQyOx+>s@oH@cv8OTu9qiuwo} z3!@dmA*O-WM4OcbO$SPozLzh_TcpX@7Tr-P!0G1~_vifM$3#W-S6XdTp|{4Ad@pz6ycC2NTt3@7>c$j19lnG*y-Jb?*M6=;=;fx$elfyl&q`UqIKi;?Nv-y zWd~Nv)ML7r`gT@!Ht={f8<|{`N)jklHt?KQGQ!LD9Vc$XXgLea7E`5v{X9hs_t%`??fsSckUugD31FtVlay1(<9^iMtC{F`*X`VRR$Wr^z zv&S@rLN=WND2I&ay-r$*|9d)R{+-`h^C>F=&(2VDsJJrh~jdr|h?EKRS zs9{L#vI6>=I<7-}8 z5hX#I7gb|S(P!1NVsRcNpu^lB+=Ft7I2g?@#@i*{H(#}{ZN|z z%3l&58m~YDwleqW(WhtY7nd*QmX~k8ak=OXg4Fr@O$lWrd_OR%va5Rx@bs1~OFf@H zy-HKG{>1n20OQAtQnh{67;f_EKzc4c{32qdJOdiN9Y?m1wIuEjPnFriQQPjhdqFix( zg^o#?aIAd&8fve>BLJ~-Q|J!nxBXpRykbu{EKVUWO*tFuQA>5^A=z0fqp|a+$SRlB zk6T)PW)H|M83*oQ>>s4(=y-3bzT&8vxw)eE^y9v}Q$@~a&+>-6oVm@`^U&AF=lQ{? z43%?sHZ}%B4t8hHM$7bdbseoxox@=6`lO|7g2o}yrl|#i7wp$usy=p9lqs%Vqc3L% z5Ts3o&53st)4?4500*?orFCC$G9p(|=Co=hq^zDO{-jazD}SwXs9am!j?L@ArTKFu zB`R*=qB1fI@AQ)*51g|{0ojLfM9c^xUz7Rky)Xu=0Ka>_o}}?x8pvR7NATY5tAqz5 zS_M11iAuDsFxy%f3}ufzz6iL^mJ!04ES_o25st?d(}D^o(KE?>S3C6k_?1b;RSy=f z@SdkJ0`n0WJN7i7151;1x(Eh`x;*T~C+Ln4p5shcZfhO`~tQ?%6`t&ix*gPV7LG=YR3aeq<$=W*+Ef7qbGmv9~b z0b8lsfG}Eg<%SoM9w%edQ@*1+I#{Sli6)3!;G6}%5A>9!bh-(-=!C~ zoBI2JRBvmmwm*FxdV96d!1#=62Jt5W>;7s@#Xf?oTV6CYG`}OkcD@TIWUGV&8hdvB zf#bJog{;H)GQOs-oaxD!xZf_pQaefN&pDd3&{AhQi`RQ`(YrYS3*nrj<378FU&_bW z4*DdF4G&-KmusVC^*JCUbRJ}UGO^+j^bTeIt7t_6XVQ$E^?nb*xn`??n6i_pX*a5O z&fyzm&kKDbBn(A#M-}BY4-u$(5Y$>Os6m8HdmuSMVKl2+^A(%R~q zM}O>6c3EzC*x3DqwNrN;&&U!OrXJdq=15I-o}a0H_l>_Kmh<_wAV!Yoxpn&w%h(?WZaHEqm_bHc};LW2NZ-RU9y zqPX}E3kW7h(YS}ZwQ9|$2!9amx%FQPk*mXY;|DxUt*q_fIg02s98GT*<51(jjgGE)G2i54k&FZq5l;5=>5Tze1?}g_eM7mOlR!{e+v!b zSMMCIF(f-y8uT&dGe&4T|AuEAvAa;{M?!dqUU?AWqGu(-~e-#xL>eA25 zzO=3HsHiwd#MXS^j^Hr=eB*Sy{HKkpA=Q>)Yj>A;H5g|6Rd+2+v$2Y zOF9AsWn{b{)LA)yIJofHvj=AF@+fyiL=Fqef>baY2>4`u94`ZA%x)zl@QlY}|Gk%$ z1!{&#`pTn6dquAB@$lqUA7!2E321C?&IM!uMRteIOq%b>vLHp*isZ-F8nFVi$TxIS zv>C7DrDJ0abYI3{2`hNVTfo%|@LUTw5|2SwIojL1u6TiY$jBlwFmU?b^}y+og*5v? zudq{5$%P;DR9V zva$i&+0iOs4($8ebotk1@aKU-fsK{*l#7d^W7`-UIBWw^ZVst@dU_hOQ$QmkY;6aj z^!=n)Ruj-ZZ;0G@=JPLsExqXUL(DVSY>{jU?8Xo0Pkx{pSDSi7Nq2sN{EcZrmNKtVht)b@M!|cVdTdpvbAZuhcCQ{UV4wDg`fgQsNh;c_U9T@jNopgdKT)-bLZe z2Ql$gOy~nM4~f%M@AEow=lb;`voAuADQtj4dkf(jF@uS=GB)m5@uazIbKnmXJYD)k(s3 zGSe?OxWimW+sDVkz`zFKSeQKf)lpv$I;Ir`B_lO82j9t0C6B7A)(D5dOQA3w>ePXV z)d+?(jMhqWaT!@ELSyV6OqOrAgw+63lWDY_6fg#o-n*A!E1|~$+;G5?EcKO!MpFf{ zUCsCy!&HaSA3|;@#LytsB(9e(U*D*> zehD^Tka-C+6kqC?L;_%pej?Z{V5D#=Qq@K39ERK`fBxLHYu758Iczw2kB_Cl!`U~A zgBZIWR;2FX!>I4rZ=fQM%!F6Lqv`1a2`s`oxfrZWEHl*0bdquh4!|Te0QeAy^gQ$c z*ZHC!Jvs|lkO)duBlFH_@hWI!kN`9|NCUL3HV5%x+xtr~cW}(yd~n$x+}TuFG7SS^ z=p8#k*qcPM35&wX{_6g@pVhWLd-m+{{fu=IAt;`XW(-?0;8Pk=LlWGhbvPVO|NdRD z#?RPr8!d`bL71Z|Y7BX=UmOaoFRh^rt9u6~@%&dZi-^HJB%-@^-QKO>yMWS5(32^8 zw&4wpe<5^Y7&Oip71_kbjEe^0SLQXvHEll2Vz@)b7#xP75A;2>dp%WU2gL9cHDKDf zKpJnm2Ze28*V8TjvW5tVh-vU*i$zKA=IV->F4k7Pl{2lwm={Eu;D!o2A!=!wTs}ma zzFea10Q{|mH9m9SuVQ7Lqw)WZ1TCaRu+X~i6%*6+t+p2w`Zf8=6Fv^`_q64V=hAB0 zfgO!;M+si zc}N@xnmI3TZ$jsDid#k!#3T1TOl{5pkdJ$0oHr6JrP`@K(Hp5WS_>)IFqC6raBkH9 z@xb!q^5?SZ?}E8Mh__n{cu9nF~;vT&AjY?w!0~}U-e0)Q$4E5N2 zzhND~hipd)h!Ge~92S)MH8Gf6TLZx=EiG*#6B2c5cbVnt4(%;#iohy^q15qe|4e|q zMUIss>KR7QY-+a{I~YElo1TUfK^)51)(8e^Js`rUpo4OUU=;&@p;W~Hg&k{0PjDM;GUg_Djz@tMP~`~J<};!CxcxoW57SY%gc>vg4Hdy6?89KNsKxIt z`5<_}82+EPuX>RPv_OmIQZdD+Or&L)*eHR$%47DF>$&`s^j|~-dd`9YJGHVf#c!4H z22>AqE&WluEmdDY)M%_)R;WIL4I;fFIh@nIMiX(RL!y>4F?z`o4u#2^ZpxnRk;=No zFH*pO<0F1(cWz^35;H67pc9exZ_rK}BHy$VE1vKz2x#i)XedW?y?1B2%Le&hID0OX zBb=8`VJfFJ3Zg!oFz0%T$7jEDewZUB?^DuRJF?>u_@pqs9puZV-JSf;!DD{Y?l;D z9bAbSCYiZ@K@v@TI7&Ef8J*k8FXTat+1})Y8D=fdLxEI6J@XPkR_J)$?mq$Gy1GPcSw_o7M|XbiM;Smwtq3|F zI=Z5V57!lsziw+2#Ik(wnAx~(fgT%Y;L9I?BVXRw8yOLSB7Pb`x0(|jOs!S(L*?>H zMRqY<@SGlLDGdT9f9=6ie8OY@$E^Tr4&OP*uyf~w6~cTy7}qPC?WrRfE1jI3!w=bh zc#;lzI-$ZB+s#xDmxoSRtKh*4iR#r$VFCh_RMRHG4r|}3;AfuM@Q$>5HF_=fru6Un zrrzoRYX?ekN9^8q%+AeUUiF9NiLL<(5!e!kvozy|sDOpaL(4MlxSiWTUq;~0fuqwk zl43bT{RBGEc7BS;_?^M&(<>X;R;yy`=A)KcQ}W2}X$L+*zE^zn?6*G%7bSai^VXNv zMUIp&xE+@Uu2M~W7SKG*p!cGWUhl;(+D62{vJ1ZS21erzDHR0zfQm!j3GXW1LCxoSw=t}%S(_{t({Q#=7v=4 zU@sF$W;^@Mh*X(@i{q|nU<}4^LqgWRvpPf5nyH}$Y>82nl453bLKDjLm8{FZe?T^r z@h$Q8?dVfo-o%!*aFALA(uiC^rhE|`^cI%9j7edeyTT#*aeaE^+yx^7FYxfpS(63t zFWH4cd-tBj>dPHZf8Lj+^$v_Aj+46`qr<}|Y;7kdCq?-r#l@koD17?VucxW%bJeb; zH^{xYWeETwh#Q}kJO713Bs}ujFX^e78G{tVdZ}kFq2Ze?pKHi}Y;Pw`^a$eC)g1Fnjqy4#$^MTl z?^Xgb#l&~B4-QVPf8w1ex=w#Z8LAbY=qHuALCeegH5zx`*E@W84mM2Lfy)DSPomM4 zj>HZ%7YSj`F$4@$8|Co7Ev~ zdXG)9TG32s)|ChoVOtGN;<@z3ddv3@ZCyOy)h#I~C@3PbquNE&7UpIit3I_qEzsy- z6t!9A$rn3`73B=g0zSx9hVF4{wTIXtrfNE4WK{9D_(9t`qLsF5JNH|CE;Q~uHQ*(4 z{$8w~$6y_Cko4oqIo5q_1qqsk5!t?8&GR-PK|!z{>b`%ZyRoqha2=NzVZY)sGK_!L zb+_dF?=R7IIZDzh9j{^Fy*34}3Pe0m z=P@Yh7mF2HPrs%lwMwxahLZ@i22^m{INf>4%`*K?)KvcZlcFNLb=6f>eeXofcdXHq zbj24{W*TW10tTM>*?rN^qLuCllNa~ubiBq;g4#2NV8_`TDEOIo5nDybAdy*hp?Q^kgeeP zB|ete?@R|Gq&37in+C7#{HWls^zdZIF>|4T^%2a!_t{--8ohYXe?ejWP{gCSngo*4 zPnigMie^00W5#LZuINsN?>C13!2*88C{%Joii4>>#BIOe0Z62{LQC^xe5~gFs`6lP zN^Ywx=b&-~yb(IALR9$bUv*{*Zg1XD^ymYru2;`<{e}&`!=Dci)Dm{!IHYMe>`Iw5 zJ$keg9Wf#=8;5e*zr3yb`XV2%CqZ9Nxxcl_C|0i zdSF(8lUQL{*(3FyUU^Gmh4)b07qaM=QC&n%#m>_x1S}~@k_rGBp%N_01@Wicsq4vU z#-B<*4G$l6af#e_ikQ{7`_KP6ZDhoReadTQJmr1)ehLa5w%qV+yRR%}ziZW8K5W?I zJ45}o$39|Y)6B_qgR8g2#7H4*?qAAZaa%hA+UwCYK5r1k;sE((ogZH-zmjE|f%(L! z1dEkD>hl+kjbQPtF8=`Yr(AoTGG)Ixq<8A1J-@jQ-2~ox999j&$F}a8TAr^MpPH&< z&)182!gtN2oMC^B84L{0 zPh5k`pV(PBfjX;0jd8Wg7SN5BQVgn+=xi~t6F#(1LU*qzoq7IX)l!aG-VcCq8tnpe z8EyXOh~?Y9Me5-`(@vJ;Z5)S-#`iE-S3*po;J^RkM?_exAHv%sNvgHZ|)M7dHy6{P|EKW6{Fi_?eEHoSXiciC%P)y-`j@zcXC z7aRs^p99dJN6j~+`_z0UJy|kfG^Y>{Yyvg`L&FWZZUdQ84;Yw`;&u3mMZ$($?&G#F z5DN_U&M4K<)%`g>j#f3B{FGFn2$n>2^eCD*NST37ZBg=)R->qM*u74|x>Va(iiv5f z30WUwf7NmWwO=C!_Hkm$AO!nxX1S1m+dn6{L|w6m_x0DZOHMnkh2bN6c@>@i+G%i> zlC;_>6YbzlX*(r(F1hdMzc3~VmU2Avm{TdAg&#%l6rhfi3k`2s4W?6{Zn1`WhnUCictnsK28-N{?>x@zbYuUf-0jYy{CrWW!Mc;x}{ECiSzw_Ps~qiq0c^ zOjPPfaXKkkybo$^HqFcbc^C?1jtMB(KmIUK%E~e0F((tOBifYUmOKDh@C#}IK`Qe zS<~DF-{$xn&|gig-(pyT69W>Sb+zXPzT^b$@|}4IbH+(kV;+N(4Ql#qe!(Y=j~+dG zXU~OP6j^U;xiA7#^E{7bglPl$wg2Sv_Rj$VnIwaruNd0H?S^vHcc^IygoBew8fQYc zzzx-=qP&TQ&@Tg92~=41)IODj4ym(r0ZuqCu@#~d2O^JE$rL5XN^i##-1E?`OyCPD zPr|3v^j0C+iU{EpH4?%T^af*ZiEqeqI%RyUHkjwjUg;~(qa}E<=Drthx!sNFZepW7 zNOjJ(7q|Xe$T?EM;!XdWi?9FrD&!5*1hjZ_HIFE_SmHTX;FwUWWPyXGIf_pf; z_d~(yBiOHFj0482u4?228$XO%6BB&z&JYK&%WmD;woYF~adslpM7*o}pf_ch*bRK< z#i@=~@TG+0DH`NSg)pomx90YTYZCkVF16O0nj@qD6ddrI+Kav4t!jt-uPRXEJP{j` zAnjUwiKhDZ4-L@V6BFk8Z8FyqIP^TsCCk=ltrOCUCTl z_I817efw_QxFOejfz%?~dO$WnzxUbaD+gAyShO|jZho6^Gqq?>ZCe{d!^OF~oErIs zh0TqP5>x!+ZPZ8Q@|;piR_z!#!C)27N?9Qga`EYyCUc_Dt^+2wC`B)W`(C{!?o0kW zY{6r9$80k;Xc#wQxnPiW>Ee2ZcL2*w;-mCxQ_{RYJUP5tg36I`>()H$2)&Xe;@cX> zw%gEkM)Xt1DSZI!J#vz_DFaUdJO#ipMWVO}@u(ZzGI?DS!`AbeK)u(YfI{mFr$Oe$ z4=XyAMKf#TWPZHaZEX5(z|U6xv@PJ;wiV!=sFTzG2s9SM!M*nKeF`#7^0@=}?GHeg z|2#Y#Mnz3l*&TRv1$ZBE4bdR%%_Ab*mSSPKct$iy10N#puc8-oHp6|xQ zRH^(30*@8Hm=Y9;mX;Rxms1#+6NPzGkP>ArANIi_3XCj)WCv&QFfMMM=i>G0N0|5M zcdPLi&M=+=5skJl6J)IPxmf5PZfc4>)_*)X?v`LJ03!!HXtYp?KvqUBg+0yatSj;_ z+G#opPH*-l8H?Fz*`8;fV|A(kVz#%xk26qda>$j&^ge`fO`|;GXFscfCy^+7lCLfN z(qlp2Vnahi`ba`CWX#>4r?m9?la%t(58WwOd~55Xa=*1;j$gclBqAcMaV>I6z#dJR zi#2+1;NQ(Ay4%|J1B^|C82 zLIiH_)G30QED6`1lW!c&KUdmyY5*U_%!Bkz}9}2)in#( zHeSNpreSO}%c6_Qq!-5LU+Um|^%lq0;wHORPZ*5JmMtWEudhGB`U6a%}5^W$kkTlr8&nfsKZFh_p z)pk6Rl9e{Tcb0&94-F2E=T*F@tRJQ+)L%k%}C7S1H?vG3i9!n&Wuk5r!%`sfoJ287#cFk04)Uo z3#jYl+>k%L{07QdQ_wNM5xZtlkm{S-`{LF;+zwF$ zIHDdsyak1)%p%USy~`@+b*PVsVH1DQP+kE4^{MDvw?xO7Gwx06_o7bjC)Z5b6Yrqe zf4>OU4w%SiT$P{}eV8vY4q%P{Lxa#MYo2p=6x0YWGFUmtfkHomrX@DvO}@ibbkAXv zRSX_@Er_narbkVeDs8|~Ml3N!Sl z5r?bb2>w2UExV^!;mNoLj6=?0G-JL|ertHO)BR}Zpd#beQ&U&E+uPZ}csV%Kl)~S7{8ib>@%b+@$e;Z2`1nvpeQ#LDKIknKtH2kfR440q}GhaB8{=TbIR=(=-P zjC&Z?nCo!~cjsNT&Bf%1UySi59DLZ;hIt?19aM7(Ji9jeBh(vlEPEAs=wik;RbM3; zyK~>OJ02QDBO+)}z}^eQrdGD`;P_!kj`mSr-8s)ejCAE@Mx)MLRMX@1WFq!N$)bl5 zUpXXQ?uQ}H%F0-Iv@;_o{ouaYdL0lOKm!dz@cl;EJ zHByj22LiyHP zv6bb}i>HX5YICv$ub8wZn>JzUa^M;Uy=J;y(ZS9i7g|8Em5vC=w<=PQQZ_Ih*`;fN z*6udKrWfEGkwYFobrU{&G^C7XEFS}V5aN1RjSKSkfjKOmUxp8@>Ym{mazJL$n_1{z zW!$$nKQSwb-@tj%oY$eLsi}Hn4$`G@8WF>myTE%1e#3P>1~*Snlfyi(`{&0hw77XU zus+vD`LDqrqQ(}oK3X3TiZCzl>W)74y^U$*`H)lA)MGr!R5Fd)x`&=ixQVIHb|WqA z25RcPC-^oNkk0w#Ctfs9KN9*Y%-|m^pwQ(eLyY=R(?{$n)oc_y?1N&q^AyvUUDFQQ z!h5l-;M{i$TCUyad_O#sLZoZ3RKnyWgDaxy*1q8gp74Z)1Ob}H30HEf`vh`eDiiwQ zE!s+8U8g=C)=+Jlh0Z3fJD5egq{n6tPA->f#Z@mUysoL+>ZnhZ>aSO?Gci<(8wTHN z@9VxVUtk5#5)qR)a%v1FkCS_Z$aG;1?~QZ5IvhWKHGIs9#qG`enwounAE`FkgM%*m zHLK`oq}ZNd05&gLw&|y%e!YiyG%u0;#>UK&mn$Hr2V@4r0cZiOI%^ORx5s@z-8jmi zS2JgGoO#B*94$BpQB8a)QjbbD&}$83sZ8@MUXv#h7H;T%=kDG7C9F3VDM&)q)N*HM zj16vOzw&&oi6Ljvb$jtAc6NnztIoy8#H7sdFwcDHI9}`JyhW^i@&iXu^<1*DpAIem zwq4kx(5`!h&K$_~#y+I`q_#>1W+Ah0Pvy>`B~CTHUKRej#q$Y?TIwx-LCw_a}USV6-59t*lHdV5Oui);dQysbY`mi zaTX}%pKJMa_5m$pT7%i@Kt&v)zU>9vBI z^|8m^&PP{Q+&M^T7+^Hqg~XZ@HZ&>ey&uFp{xSxFTMq9-U4xm#GGw8^#`L{!;n4c| zx#F6Mnl|(1%@^j+-JIJXF7>LqnlU3E#x7*qgIECo4_P96q@$jWbTs7R=Q>%sK%Xl1_LmlH&4Oi zmW98hv^4dNlUO<4RaPBK4eF;viQ@k3rkAVTgm_{ggC~9V1j8Bj@s?)rSmyM%(Z7MK zT9T3R1t4Zxx*04e+T8?enGCD^s2HNS1>vH6I6^9OyHQGDqAvrx-G;z8SWDrmpk6wZ zD8D6cZ-m*8+p9h6{5C{JMuPqa#TfW7BJpn4RXsg3pgX&~D`*+37%TM@pBnGy2R}$m z{Nhk}xip28lvIXxK)00)&2@el(st(7v4iCicjTCC_Rq(vA3i>RzJKbYm_^5li}tGd z;lVp5=V0ixc;-T+wOz+m2l2tzf}|~1p>Tb$nEL8ZlsaFE{>BJ!EIQf^*(AKo2GLA}tWXvb7HCBhSJW)FkE-)8MT@hA(z5Z_8?b}}m2Se!C93wxeyObH0 z+ue9`@b5l#@xAKii2_d2=b&eNk`cd0+CY>Gq_VRtIY*b!v`0xP`ntAW9?T}ljs03W zN*mPAzHpzL5{=MeVKy<^vE%U@h$FWuTl!g}aDoznF9BoMThexGOjo5;f?X$*P(;@N zUg<_oY^#7X#oTuUf_)ehW9Q?uOY+-aOAW)S9e&va2;RPd^D@s)4kfRLBc`my_1NI^ zuNzkFQ8=C`zs+36xGpAwsHR_C(>dU4oT5f(b+gxhZS5hiXR7BfS6yn)GSj+nzfY+2lvpXwSvP#c;&-()0%A4!7Yyq(zLGl0d&i^=W;=v%9j= z4g6CPsDg%shJY6-Wy_x7wgl0td3Z_aw8iT%KhysDYBx z-uw3Li|Nch@;fLg$zNN$G1G+dgPt)*PaTzeA%7Bf2gSy09u&$PK>vq#=sPn&rmgP`i5S77}e9JFpJN}e<9hA z*Pyx{{n;Y6s<}DSZly*1($lBEW1mG9Q<&58-1KI32dX$agCy=t%uNmN-%E&onJ}~Q z+m`ghG8Vg4O+y3KJhNc*odvJ1%s8?0k#}~V-kIzEO21UGtVcHiQ-c`EM620R}TZ8 z987V?F#PQ_%O(f<`BN)LfBJ^h7;dA^m(?kR{C@g-`17@qT#BUjU?#jb)w=UnV~wi5(faFQ_l>(w>SCc3t2m?)xp%<~Ip!>5(F5 zWOmxh2-e@1HLiD{Oj7bD`TvYWj|iudIWGx{)mr8C}A>vrn7C(DD^nv)UE-I}QDn*>7UqTp_m{uAmg1|3p zcyd4QK6^fv^jECn%%!tzZp?~5-37JJCla$+{m)R7SvXsHg5ff&O`%T*_zU^#@ z?349AnKyZksMb)N+|b_fYM8p}kk(+TH|I2q_*tR|&`UeImH(<+I?xAj0H|qcC8mfE zl7GsOfc8JsDrnJ*l=T=4L0k|<8Hb2}z}Fs9*rosc(`h*E&k(UN1MhtG&(xk*C$eOKsyAa zgy5-Ibjmi~jy`A};d?7?OomTGxqaPdh(x`z{#Uiq}+o z9EQ+GVTolkBoi4)sk(mqM(>D8Hv@vwmYApl2;s$x13Pwf;K}ua9;P|oFRTzcje-+x zclxytcV^$hNPp>F!6GNq88bdXC{pfgUPCHVnD(k<9sDoG)|kc`{rUW)<0jSHv^seu zGprYF9Q>F4t_~kYh4RdAexm?C`ystnv@Zmcti}!9AwfyL1dL>0`vq<75c}CKfMM7P z&tMP;bq*5gq#xmk-L$oS*Y1+eEHl?n^#{?70DeP0JzCID=xq>?oQKUJto2cT{>iRP z7N>LrgBVEV&|TC|EoW=WS+;7GUl!cD>uiYGbn=aolB?=L#h{l##)qdhExj86Hb58% z5pc@{QFPFtSRfu_BW!J@wc2+^1|)Xv*ulST+cr75xX)$ksh4R9hdjmsvi`TD@CKZD z(l3Cum^t3cx%2{onvu9=3(bCe!xTBc<1`B^7Arw-b*vOW~0`fjW!htRT z#{`_kzT)7MaU=u<-t6q`6jV0Xz|J>sJ3TQ_2cHEP*5+EiDFI&=b6RyPNM;7Hp<#Oe z%xfYrF_G|h0!%WChR0z&9cSl!@A4ACki*FD9L6%%+fUX2W)>7Y?06JO4_K^uHk%9r zMu$MMh0j>DP9q92hG+1BDF@33xNXSC+G_Nlmj}UWaRynQdOq5|Pdydv1JpU=lao5C zsse1xLCA##1FiM$ZsGV~<6QW}U@l(x=uvfBVsdhxQaO0I+EdjvH8RH_;#W{O)j6)Q z5o9B=Np(I_dZ5iW#)Ulsr1lp*Jrtk6=H{|QM9{)aPJ=m6nqs+TY_E&U#zO@Ri3*B} z7}q!=0^?oWWhbUn5;e$Nv?@{G@N(}3GtWb1|hUZ$pBsiv|R2od&I5) zE+mUL6?Oq8J&E%dHGb_l(UsC<-p6FiD>Q5b4`kg@kmcf~mT8|;2Ln!n9AFL%D2zP6 zze-u_Kb5fUNPJ=T2SJ)>2X65rg)UNnwzlQ=m@IKpf3rkC`mpcdyX5WvgFGfJjp!NH?G{2Q+sj_SH zi^)1R8(RZRI1$0tgvpJXni`PakiAE7RSi`wx^2-R&i@|UN8O%bB%JEW9_7I9YWG}0 z{}$XU0Jld*9x6Hz7ZVdX8atWB#!){gaxZKOu9SDeN=iyTi5Wmc&Y;w(-HNYY7eQXT@I^z^~{N=)jduzM<_pNkq4E>E5F7tYt~QVX1Ttw`V-){e*_K=wu&`t8=EH@?vw1DCRmrWy}Z1(bES|FS+Yq> zbR8mdAHnwk?^eB9f+aOw2*|a;xpVTt3{HI^fTPNbW@)Yt5sWOD?Umj^%ORfbf!_cn z({ZdMk4i{rHnefq6QR(U4??Jp?t2$15s%7yJin?50&!4{;@aHhp`jsVpI9qgcTlRcv(L7Q z@A38pnc;Yg&z6LdnwlE-{<1@NpV=#^xetwg-*eF-`yVV|^5M0ERci2p7%Y65wC6W5 zS|C%yVu*gNLUJW?z8xnRi-Vz3&}hg4!S6~Y)f5H4KWJMR22CHFljau-_6I94l4cPIyLfw0?z2>oidIv<}{w~mzp zd>c_~h1djqknHujtWcw_x*#(8W$~_$x~3-Q=ES0B&%kq|chKkm00!0Ec4AY&15F%Z zFO<)Y=*uWed^>cFvmAfUDwVa|amLx$*x1G8BM}yoewCelq?ztONT+DBOrJ$KY{l43 z%at5XTfMp(vcM?J1+PgU{gdqIH#4G*CHKdyJtq43B5~Z*ZI_qV+#YypTdVKJEE%G3>Fj@^xNX~a#oa*C3u zz*+`|a3;V})B@Zbpx+A%x9#q|O0>a~8LH&i@!;Cbrqw#m&e`nC(8zC6o~f*^Mhs*d zI_0IgQP;u4SiI4(Q(m)^dW7;G?4f(N!>(xXiKzkH!urA73T*NFtlMq_U9s@H4dQaY zm5Pdr`URvhvCG)kf<_!GOrP;Sb$>v*2T0pMAh#GQMyOy2gM1+HhQ}EiS3~k9$$1@G zs*sDD8l>wT@-f*pdTB#ErpFQ7O02o>A7q27)gFpS=;P6>m{L;GIcd`L>eZ{4FERDB zUQ`{0hL9}T^t<@pp%cfB5uUj%G%zDWUya_{XqI`_h0teiVt<9Oj6~jw@Q8I?otVPz zpOV#2t~f7c;dm7EC2`ZUy#?R9Z{93v4*)<=M$wT=xB2z*+-LzF4U5Bv(^8d)`46sY z@C2sJ=m&_3cTkk@>%iPmSXhgz^5*b6R~nb;$?@?SRMfckk#;a?xxxbij(ShbjT>c- z&8BT{#Om?fWvE^boPbp!CLpZWjIhelFMJ;!2JLOL_BxgMZ-g60#;e5UkdO^QHqH;0 z)rX?;^Fy)c#_xIPwDvfU!j7oO$d^q6YbQgR;)sg&38#5*?8l9VV-DBW?U9(;c9g40 z3Z+K)K}~_WZHi(JZrA)?XLs*BJ+~cZD9z1;77Mt%Y0|1<+8Ye*^erno+XZ~L5Pe|#>2v1_!hWdf2yw(PFFv-vWG?Y?j{qNOk~|g6FQw|`H50j|B8pvx zE1@?g8^-#WCBbDVDK7q2md7(YSJ!TktI6bmX#+!Jv8#Riysd9(Yt~W_v)wQ9mX5F) zJf!_9b7v(^N+O;La8cc%TS-Yj`uf<}*wQ~{Cx(!@UVU++sO<<8Bz+zqw|l?icdzy1 zW7{B<2QOg7v{$gIx|(mtj(yF?VDB(hSz&RMpYod4LvslwK|u{XYUj`H;Yvvm+V$*S zR!sY=e(lf;^WO{8j{rzaSVco7;6}O_Je63w7k*?`@|5T z*zJaCY&^ok@7}*x!&^rEHHeHOG$&Hz&D-&_2{=0Vm!1*t$q=^{BT~*?Twkzuo;sNf zC4du83#4=(H>lA`M+((w?y`l~RSV)ehE%u^8>0F%KG~`G;q|x-@Cy0DT|fxC@S9W! zd+VvGFefFCQB%xq#0L{dEse*MbE2PIteaFUS2wo)Yg=eAi$~J|t|zt;tUMT zVHMJ~X2-yp$ikT|ClGVX&`{C;diT=O(%9IeP;Z^K@CJ8Bt9>JDNZq4-rhH;~e?7wu ziYG@5t|L4bKW|KI0rcT<_*|kZ6}7thkdCS8F*KCWZ2y1#?Lky0@bJZtPrZLgFR_6J z#@$U)|NN}J^EbagJ>?fg+j9~W;lvp(_wU~V#RLZ$tcK*`Me1X<-^{651#xXo{c~;7 zadk&VN>DDq6IZWGMO>&};wHmm2VO>O)(vhec9-P$m?wmVg@LU0eThEo-)r~nU{Gh*ob4J!EuE-;>FFhXNa z4nt*3TU(BI(8nBtF%R(!7%%aDBaC)2&c>ziUQL7c!f!D!co1SvYG`|Krs4D%NJFXS z@b?M)vVmf&=mxAOQM(oP1o1ZigRb)b0R#8AU6|`2S$2A2LPlObzDej0lcJ>qQOLI2 zGt?7ipTL$99?4mDfh5y*taKWP1=d)ZfPL~`S5=vLND3RV6KOWM1;D6A%tLhdW0o8?&C}etzvhSDl9{40KY+C92zj@+YY`$~vnV1jz&C14ZKFGf&-8L@*0x{xCOz4Lqn2uQN?_ zZEUt~4MX}v#FpK^FfkC>2`vX62oS_{B%hJw3&?TCxHnJnanT@K10o)ZPDn^!khG7% zr?InzpdQEn`t`+;{g@B)Q$H>!Aaob#;s6Rfk$R_gei5!Z&{#^tNQ|K3tN1UNdmDgN z;L`EnX;6@(cH`5^%6mXHr@t7SMc)A_kDBw@!N!=;ZkpE}2ziFw9Ca_TiNoyxBi5%X z@k&Zcc$R*A`xa=$1B<`cV(W5F1-@lMS>q zh5~SK|D)D%c}cakG>Tor@O^o{*97CfefPmA1bd|X=gZyLiZDasyI$lWs30b$W7v5W z{&5$5r0m(Gq*@`I$@uNs4w8eJwYMNI?^1QpPt+xFmw7a|s}R~B^nqkEfQb-DJTOX+ zw3myekHodHfpSrNKn%g)F!0YU&ksG8}2cyF-_N|f$TX=*fAGrtD z`GQB#`(R|@aRV%rl$TO4rMt+2riA{Q`*=Ib`k(cz&#pH`XWBwUbrj5XTgQjj#F%(W zVYLxYTF67lhyALpmk#4b)KphLObYraX>9z4_35bVhYfWV3i9KkaKUa0SBsGZ|H#9m z30TL%Vj>302mE}Dj5-k7$2X)Jjf^#nZ!C{G-CT9j02LOYAQG*qb~zOwVS>>6Pc1Fm zqL*NgGb#AqL|wf#;tx}d{G{^f;`lf<9n;O*w|%GDv{3UHs$MI*51Axj01f`2_wP$F z{|0LP89>q8x5uq+-dp+q^!K}rBVrgR)~!R}F#a3%4)` z0aESr7TgKHQ|MP}>6Am{Kl=VW=u7fQq~5cq43A5|L>(KlQ5$p@N-zh9jcr*OqH2E* zmk~SQUF8|tH+5L)^X2zETs zQ(|pTQoycPRrS*KSgBsq%d$s*4!a(@qj1S?A$-vszqhZ?_H+{#WkJx7IqW8PmAu7} z-m*A+7w9!sJ*HI$4Jl+nCS%vX#ho^VrNrMy|C=L48d~LWOHHv52U^0{B8OhLW71qr z%T%p(EBejS9i2{jZg`?K(?3+Y!8@g)B|uC6h# zIckRX_I7E)?zkALbWbbGJ6NyT?{^1VKJWH$pt0J23xMLaYo1`_?CZLF-@6UzNIT7hto{0W zaXE>cu zRe&{<07(bou7=?=gcbLiWdBZ&_0)6!PLETANRfgOT2A~?u}fAF>c(%CbQK5y48`sO znU7Q+pu*a_kp8{zZDV5*+6C~!qKWM~Wa$!5<(oGIp4YVH_QuWfFQ9S9O%-FhdQ}TO z>=W;w$0phLGF5~- z#Em4@pi1!zx=$j(90MkE0=HSP4f%L^-BAhX?;Z7~`rJCXO{~!et>W1G*%A)5G#%^7 zSo1^b>PPbv@BIMc4D?6sjve-1P8-|PSYW$PzdhSFwKnDAu;7W0J!)o##q=I$eqtmM z7ah%0PiA|tpg6FM6e|P>M5i~>IYDPJRN_Ba$7)i5$$3D5h8T0$fN&5vZdmdYz;gNS z#-wXKiH(ncW?NN4io2GVmzQdg-(UziY=Q3koBS;9)HvBDB(^+yR$L7B+cXe144;6< zqjg;DP#$nOUbWQDGulY1P%=RE!q0E{S$t&k8XC4~lg@U)+8^OV zIy7{@J^a)q6lDtC8YCI0@uoe|%f5k548Il1a3XQ7+xo)6V!12y|2nvkKOQ-9MDM0_ zKL8Vt$cqOnKM(N3yN`?hmDW_1L8lP2Mw`LN770ZW5p8v8^E1rhMQ>`mx}Ns9sjnPu zkN#LUAG$5OUzYdet9wt$oeOE60V zM7DePh26U&O0PznI~v%tE?ftZi*0Of?sZ7`1(7A&zTa7z*KXIz-+&P|y3N(yKMigW z3BE<{pY*lBd6*x$A2oPttjX;#0D&%;WFUTYgW45wGs&^HPia1ZJEaIj8wwjlNo?69Ym{K%Dz2KO->leD)iTWLj`IQ(DM~^d>d$v0K3>7^oOY- zguWI%Q$CzIIcSwJ@@Sh=cg??wh+sry z==*jV1X;Ii@$0XyBQ@zXJFH(zeVJ9l zi;5ptI{&(|vI*{F98j*(v~rld@aiJ#aN`)DB5A5p$laiZ?U zlE}I#ZlGG7FlTVdEQ!5)9Bpg(Gd(UQ*t`!Ul0FKkSFYbS%p!OCz`~p3%?yG(12IX* z!rjuO0jd-S(9tE{+v6-zK8%fFHt5%O(mxg9Zd=a5?S^go43*VG?W_k?V&{uYOr77b zJ{uLRE7J{%-;93s>W3UVAKFioIm0>82@hKGubh5@oV;ayQu{rMR*Dsm55|#b78R}; zmS|?t_4b72sdiX;0I)}D!q6pfBR>tdFbui&*jDbn!arI1@nhV?4tFFW?sqrq@2lE} zpc^jMb0skSN10XVh>+je_lokH2}Gq`@$GNxP|lJ$?Fs55o?pBCTe@sJUx4i_dte-7 zh6ibBr1r=&-5@ezk&3B!Xxs|kX6P!*%Tl)fZB4zCwKvP{ohwfoqlml_dQyG=P_7j6 zQT29`GtGzT>m*05luwUYWc89C@SIe|L-DTh=oRvm_$4>ksOT(^c#r*>p02B~FKu)b ztlJZ9PrJm;^X6$mLHs8ZEiJ0zI3CS`?%JxVer%y3h2X=WJ3^HUK>tsYPMi*`_`l;k zLgH}X<6bl;P^6kCYEq@r#cyLMlNF?o#3%#EVJx!@q+u*Wxpf-U_D)V>Q7D`C>$OTt z&y?_+(>g>fNIqb`F?Djs^3troQ)$xH9>o)g}>;B+P-0I)BP!-mlXq2 zd{5}5yFx%46d$z1T{QgH`%aGYmmPyYaVj^KF&Ntu7F;XB4uE8BG(SVNnuOl9QMJ1;!$M;YOHVNGr_f zAe<*e1)|+Ucc>Yev@|uL`#I8f#`ERU;`qZf- z-|iB=i7T(xPluCCjU@H)lSW8ZpNylPT$*hfL{>2?S!4kepnBvFZttv5Xav4jU_5 z7R9ckT@rY}cI^0+ajdPoTkD)Bv`~m`B*hmfErfBU;#AkzFRZ|m&H}UvJ+Q0j_Rvll%D7u1K zv|9nCLa&91&kDTDxG>#7@KOZ~;UY(XQpjm=^QlcDWpG7|vGAe6CP03(L45}t_W7(5aN+OXh5Ja=FJcZqwE3_0<#8bc%eQ+; zc-IXsxm82_;^JAflq>R`Ek;34p2!OEe_g@K3|8L}hP0#a4x%76X`vT-RE7K@gIf>s z^8OlDIXi=J0x`vle90tZ;1iuBa=nyHbnIPSZSw8w5GM!&tf3fmX`m)}7#d#x^HcaaMkE|fOi!cT z31$fCvtfu;*i}%gi!eeUnt7$$%fKI?HWK?!ItWf)h$Why&x(N?*#Xw53pfGsQuNPh@C2L?Pw+er7jasG0uBLx!>FQwN8KVY%pu!yeInKtv%MrLBkd>EKQ2 z^_Y{xn_Px~dH?xzQ(P-li0d8qRQCY}1s2Oog`m5V3p;h@(tpO>yGJ-smx^mTNuM3* zL+z`fu5PO!Ec_Yx1DvSPyLyGj4no4XabqM}+XBehJ##L`4uZt))eNCLrd0r(rpL!a zA|hVAe95W{Gnm~x_gtY@!V9_)gpue>1^!2-jGWrv@Wl`vwJ&+=oJ^6Hf^SMIAW$nF zmB9R6i}`mqbBEU;6x=9&k&a3a#VZrOvS2Vm6Tln1eq$@*UOA+|Z)0ScKEE^x>takO zF->~j+1ZL z-k-R<+Wr2u_)Sv>b#!*Q^;J@B^__tOVbqr0rZyFgCWthGw~L3{!}E(;#+@I=$K6U< zHqXO-{4in!A(VFjUycyU|6MZpyo0CZ24ZAAe)COwA^K&)P^nS#ry6tX=$47mymv#Q zK*bL-V=$cjvW{J0=m#Oec`8Hr(H@=xgL|6nu_TLU=R*Y z*1_FybK0`~D6;C(?O79AmFKf@(b!==jS@czfEI2PthU~~QS`N-TfLE+?)2Z3MePe@ z>(HgW&AEox$p7XDTz6LF6XlHHSt471Fe{y!Uc9h3qUy-o_eMXT3pYck11A-6?AtMp zmgT;VpeKuU0770w-3@UP7?;&yEaG5HI6FFqCSWxqCkdeozai$i`3>A@GMw5_&d<&H z!1o0+Ua`^L5jyJdteD)+P5WnMwr=VYH-41*=l~&96*~!_SbJaWyd6tQXnffg1OVv%aOw_>Ln-@m^TmGkGI_E|?hkfIY5W^&k7p08{K;H}Q% zCr^xhZ($A!dF@QZ@jpxSI|n;E56Aw4et}_e#=kIVxch5xzYeS%b8@VL1OIMqbuuQ} zIzGlo&Lm)&@)!S^L5aj8crtQw^Bi3H$Ela6rl)bx0uumPK>w=GjC29l`-A)l%r$T>i`2OV#!AzVqiIhW!5> zHGjq=#P_;e|7Vb&`% zN00RRVi-%NnPb@m^`CINW2mYAdAxW2N4OnWy3HL-#ed4nrF~@UlH>saB}7s z{te+{y!4et?6Bcs)8PxTfv@JU9Qtk8$=k3XiK- zug-ZP16WT_4@zs|%8*NmB{qpuTR#I&TT>wF20skC(3==>5WrEC^4voRWuV6fjSS{S z#1D;BV4;wY^3ZW8xK#$zjbcg=xC|Z9EP!tiCl4wLB86S0V(zPMsLo3W#tbsG@27q~ z28HXfV?q^Y&z#xqX1iSE?jXqb;S~h2_6@OwFdM0j?pP}+N z55usK5Ng7o@m&bk&)4q9OBvyFfzs&-}^h{|A_yp(nkFT zWjT_MQQ;&(RSbCy@np8?R)Nth*ax3?9*$X@{6P7Tx$zBxHK@hj!N-w$<3>2|42|Zs z#*Wm@jMqf%Iy*wx9%rPc9O@}JT>@-&zxpno?c2YilsWxwX?crmqry1NuRhgmrDLF& z!VWGXG7AA?8ib<)l*AGV&*gRZ0~TCb!ZWMNiTbo*Jr@{*wL#|BChZzah} zf}v??v_-*<=g^eNaCMh)=W5jKoopv;ZTmib>L6+SL}4J(JHjjaW4bcJz6hG{A~E=; z93HVqxqT@s4EOD6g-hg4xji*)KNPfqg??@SJ`>JUeUno0Qku7K zvWw@L#J&7T(HUc^yFq53KD)=xutx+OK(GJrdBA^%c2Sce^mx1ia~;di5%m zP|er=jyeepQ^LA(e+&*z(F$G+`egL5+B^i|0bB}h_aN2h8?G#5d_z^=I5tqyk*50@ zB?2*-h71Retg9PFe45=XCm_-}Ux#L&_aq>+Wj<2YFvNBM-CI^%oF6O}L zrWEe#Ae6g%dIEuD;>WX<@7Ax@M#Y<(N4h=nTsXNgV?!nt3LVwEHl^y-kKlKTq(qa_ zJ20}ZsOT;AcJ&>vn&*?dNKD6nz6=E77@9y%1_tJV@h7z?F;^Q!4h9C~zYBX^7O|GV zye3NuZBpv63x;u!Z`f@|?(*h3bXFJhZudp3+E zSrz1RMF-(#NAj%qc;6_*gAL_oN-)@A?@@Hy3y|pZqcJL8t_=;eb^uMU2*S|sy0$R> z6S)MyIV=XK4SpQ^!{JbJXU(NuPMz8d)>g0&cK@V_X&R7W`0wU;bvLBzfQbb@LTxi> z5Cm|1$`h<+%#`7kMi>?j!~X=TL@}Yt!b$8{Xlz(IK8+%!GR2#c{yLu%2F?sp`8^<< z^Sf0g7!ya4PZiqcJ$Xoq>Mgsl6H3Nc=Ml_)d3i7aD+igIZ}1R-jDF>qRVaf zQ}OhC`hYbdVKukk`P*eU9T8(>+-YuU+sY%ZWh~s>mv&t?Ut<`DrGX+FlSGxh@onXP z^St}kN#TlOaA?2gC|%^jpmn^XV=J;XH$5r&3QAn$Ta3`1@cU)0{G%jkX3V`9Fp z8Fq;R`H00qE|gA7$q1dBrQwTv_39lr_Ybfi=3!d)a64%0al&9nc>4M-z}gV3=6#8B zZO1M^0~a#d1$*Ly`mfd(*TVO6=!F_Ey}f-Tr3WwoHGhkCm%fN+*X+LuV;Xc1;r0xg z2^Q8~HMIrYrHNiV@8|((qEmd40QX`uCue56wE8HcIcTFZiLT||h*DM;fZpA@!1*Ll zEp0;(+vzfD`)jla3bz}@G8h%qhhab&2UU{r@>f{_x#>^@Ca=TrOBrhCKQczH3TJKZ z>8UBWlyGrt1#@s?({mQ~5c&z5s<)vbGj2d`D60*X!WxgMH z>3tfzW5DEdVLWb^y}a>=@oR15zq!|BtK0^3cd*+9j z={DHd2Ju0-o$+*x%aaprFpPbBliR%p;x=MLjT991x^-+`P_h>L&C7fL!gS}t1v4Ko z>@=J%(^P%_uRDQVeNP+JTzd6|#;hwBU z^$o%i>@tR(N1q&KI$hBH>eV=cR5b4hB=lga4(2ZA>NX}I+G{354)>BYPnZHzY*h`ddxgixCAI)kcrH+`JH_HTGU_RgwKVH>*>>ov#0Pq62q<&CPKm62-ZH4j8>SkZ%M&x+_r6zzFZkMz|2KX zNcVv6;OOWnd&6;aGQb==PT!R1RAaKf9fXbAYD6VZN(cnABT3iLkWuU>#()-w0^m44 z8|ky!WC|>9FxW|kmt^hW_5yGz&%DiQs)LvOet_`iSeUF1qA^sRu3=fmNbYj;Vf{8}WYV$w5fNKTOCv(m7)%+n3_=M!h4^K}eC=CPV zM=kJdjm_L2>&!G!I*2g+T z3=FBuqj!p&GM9)HcnlF|0UQNi)zS_t88H!RY-);M3SIjEl(>`a>XynHaeY|5_CT#Z z8r;%IyQ}EL5GFVx8oVQ4#8|^PbCI2Y6Aa<|=Eg6Kl?i94cHUQJjN{wi)~DuJ>NOWJ zxz?xl_QDR!h1(|{m)+Jq@B#aM7u@J@3?G@b7Pbt>naa{*gh9F=!b#fVDLo(Jq|ml_ zRZh|Ax*AT_@yQ-K#=As!9xw5oog{4R65w$zvU@p47HmR&b=Sl6~)dGNC*m=0C-jVqx-?l38fl=ZW4f0iU| z7q|lAN5jhtWAkg2nPjOQQc|vMq&ocW|1G*ntHR$e-?Q;@r|X3_|AR>Z7aTFf zUKqR)C3Eo&NM@-EtOdU-FI@&GX%2i8{Y!0qz5T)QVz@kK9VvW?C%gFEcQ#0bR8@t? zQ*`4cLL(!~edNsFubWm9#FPauM@sk#Fw!$IAx`Zk&aOfjZ8|o`lXpP;7Ze-}lHf4( zmnSOjpo&sJ%gV!Z&#{^H4|x>GuQR$hqVUGeJ;}l942A_Vg0OAem9{Gdj}44MfV0qL zULIM!9ClJaZL5M?A7V*|VG(}v;S!=*mq6zVw-`p9HUE37G)DO7)!w|_c<|ssx{Vu` zraFcO{BIn$zQOp$TJ^_CPcU7@T#;(I1fD2h^ZKZ*Drbfxz<~hc1HVg3X!s)*{Z8A; zi_oY*^5t5w_!=cKDgcmM>?1rBCSUyXy#xQ|zCfZm_8~l82R+z%9@$0Co-?@(*63Ms~3|`Z+?zRT0put@{3jN?PS0a%$8yG(`1W?d_d`6n(rl@-y$9 zQO@%nu45f)E|>!4v?mO9_?$eo!v8lmT?u{pcIFECO3KTHJ8<_{-)j0>9?7tfZ$Q4+ z`RWzD=*32Ud>^nu5~HJWTkdc7Lt|_t$p7}=cdo8iKE9o=toG>&d_+pPT-Ze)CyuV3 z;DEk)+<-gfh8-1s0A?u{m8zdVKZ#JCFrVAUX04g9a`9>b-#t!gOGVDG%5hs;X;iPE zPlBsxfF?suZW@#b+=)E_OQlmDaY=G3m?ViUGrQNc#_fs@cTJ38b!{zDy}!+lO^E89 zTH%Bvk@WB;ExfNmFMwoWd(a`~W zB%lYe^OKVv;G=Kf@p$H&w&%(?N*no%K<9M;nH)Sgw4MpLQ1KNS-uikW9APLQX6{SH zFs{5`>L@%2L1V`-1lT)~ip>ybHX|NYF+CF=RWUy^ihsDmy59v5Q$k8=?D-950!=x) z_P=L+2t27h3Szx>cONkWq^0d?>*-yY(S4CTb7sd!519I;Cc163wYQg8@#nY>A&D7i z&+x}TEp+bu`JF@>j>%tNygh|@)O+5()iKsIx3ECMLsk?R`XI6{HWxcx@;uR7ez#nC z`PZTfh{qtat$d_^yg&5lLzCDtkDygT5Bdh4yYbkskf=aKMb+~7uQy&=I-HfdNE$R5 z5vS1HVwE8bwRDzj@RvJ&{m01_qPS;9XN}o?Y!OH%9}xWY0q&ul!q9v+VO#t5{d*c4 zY~iS`Uc-cOYN|;mUuB!0-`Zc5xPQb~U75+Q^jpM)?eph@x3*)#_8%D{Q}%G|>Bx7W z%7~bUehJ(g)RIFjdb+y%PEt`)?te!0#SrjLnjsb$XYWQuE>Rs208mbV+K|cy=O5jf z>?>C&zI=&`vnMhcNO(RSeoC;t3X#Rxhp=C)R5Zpy*iVihbYMJ6?k@VjCgu_ z*6q4)+qE+Q7V=>Ff!i4qo`rI(=cw^xESfqhBoVW(HD`X!v3pBLmh(K+&hXV9dg}qv zI`+*ioSb0j<(&cJ}gUeWx2 zG54PFSod+*u%bapiHwTO%tQ)>R5oR=gc6A|5@l;h_R5Hgi0tfSm&l&kdzOssY@Xxn zx~}_v?l<@6dGkEa-HYpL;5^U&|Nr~_zTe|}47SNxoLwHhf{5zDzKG6@s-OfdM+Y1L z=ubPT?9*1_>Fnt_vZM8#3zgz`I%n?^kMXJMmvshX^SC-ev&Uk{u#s0 z4l-=Lz!x((z=H+xnZ>ZtYK#m`eCg&zof{Nab-S-CI6FC|SEvMaJV@CozMYX*lfrQj ztUp>XzQ_8Cbn$j)F9=_4*>k9ZRdesNrwz8&)}{NX`;9ZwGU8{PCBp~Od9t;G&+h@3 z)m;zqrH)4uI=-#1JB`kQ+*QtSpg^LiBW`YcNrwkLVRLPk1FFuZaf*vzdfI=XPTy`k*5b%dnKJ=i?4YVh8=1xe z&ev#*v|`c(rI_C|M~^-w8v#XrWD(Aic*N<)leNVP%VK5-@eB#lF_HfH%uf!>-OH^R zDp%M`?hB0=2q$ax=cYYUvB-C}k>s?YT6vcw>bmLF^xX^8ENIz9vJUvedke!V$`&l2c=y2tVg|;>=nPxE~$>C?|5|Iql){6xR zWO`9xtutLMogBKfw(yJGa1{{NrvgVKV`I~-5{q80-4-(^kkw$rV}?PjZ2t!XiZ7GU zoj;Ay442}004W4`JPr=ccwLj)mp9DKoqt}T72j?j;Qp0Jgr<3a-r_D*()G?u9?C7z z++Q!IyL)X=BNTN}sY=+;^uU3^j*fQyHAX*QSIy~Z+t2N>@TLMSUg@&)9L%Z`9u7Ty z1HW$@k`r1Vu1OF5Y16gzl4-nQ0Mg+O{v#KKsII7#$E@q@9!U4b5d}XotG(A>lrLi~ zVEOO5<6(KQnb9e$#aj=L6u6Dg-lU;!Mzw~T1ds_27uOsN&p;fcxqQ(o@W|==EsX)} z1I8FZ11Le;q;21a+Ycaf5-h~h85C*%Gc)5|wU>7{Fvk#Df7a~^UqLW=DY87$0E|0}YxAPVGa%c&bYoa*uwypXX^2%e9`O-b8rZBzVVjq6^gMb%Eo zo1py4F__!ukc$2&Sg0SIfQjJexggGEu zd+Chj<_{=)X}^_#Vk7tudBVkl5XjuI)*OWbBuNwWALEiKjl{rhQYIj+8!-O=ebim7+mZ&(n@ z?2T59m95kKaE()1zu=JSZSS3BMu?MC4xT#Tri|TWbz|v`>X&k|7Z~u!3SMt|uRY^@ z4Y~+ftAL5Y`*_0Wjvn>Z+iKM^7?cgAs#t+9(>=Qcs)7@j%6<(Dyu>h{uei{}`w0hm zTzp?dqS0WooB#f`Rr}@Dw$BaA^SSRbU@VoBbBUc`vZK=Zg^++fsOUh*)X=x|0amG> z^nh*lvp_c}bz1k-wGHWwL$(SuG(W+itr6NSp{@Or_Oq02i<`!+h1tX>Jr{~YcIFKI z6*^cd`h?AyAN{1sm*g?Tb|Tta_c^On-8=}Z31j(r8lQJK-Mo2lg-IaSa%-bWoBjPm z8=KOr32E!7eL$^&-y_W|rTw@QP$w%ZeQZ%-ZE77^h z+Ecx9RVZTHe&*nWKM(2bWvC}Ax2Io1b)%9aj*O3&>}+gotRwW|QZ-hw35$7FgX zvYOt3U<`@o9wCXkxhLd{0q$Z55oXd}SkfY1vulD!YtO6>SU}QV(S7CbKYb^gco7i5 z(a(M#(;n>Fa`Y6$Jm33EL`n~oT@n%LWd6)G-q=OCrNJ|IQF$5Z9lPVL%DnhN6%iFB>zYP#ZS_*` zfH1<*QYFb`Cn8SIUkZKxxxKlWau+dW2T&Z-m*o}lW^hY>_2Tw|bqaNE^ zMR1BHCVpzQm&$fbzFegfDgro>`~t9`(&M(+w!Si7Zm!0K9%OVdJKLtEc}r(tOG)i+ zh6h{0r%#oy9Ho;4t-2aBz>Fj%^gli=oywe@%Gw<@|jfK=)Z)dy;L_x_H2U9n7~-ARgZ;z0BC|> zQ9zdfd&0j-5zo>a{iM8})VxCBe34v+gt3EJop!oMC3Q?%N(yuQ>#34QX%`i*-8%1D zJV5UP?^jff>%9;AJ?oB~wRstPI%NfeW&{xD^}OAwF!nv3B9pSI$ zTf8uUfSy#0iFTKqWIuD}!BCmp@d3^dAq|4WkBWT1H^JP0(8TzGj3arLTS)8K*%sad(eOatt!&U7J=P$Tl z2adVzXdtq~if?9#5>(ri1R7pxkWwI(69C2(~3D@!IH1PA8w-oT)tLy-WnScuS7 zeY-VeLbr=I6drPY(U&UH)4QRUZt3;H|)?bHX^~^Kpk>IodGGsN8vegydc+NaQ)oFnSn3DM`boZy4!~E zJk>-F1~CV!gC48rlZJq=%WNF{iszL<@OHr1#Y`xG0973-y28#bo}?TNbG)Z>6w`=bMI7$k)r(#v*L1R!AEtHMY~@;B|BM7b`YXB<;dcMIvIXL z0V|`wl~d4POj#1l}A&N*WV|Ep2djncd_nB*!pu9b|!W z?lkJzrU1#jj*Jd;q?|wb@`*?z;POL4H^lbfgv+Sp?k5}6`x^!YDGQXL0w zuUye+y+J*(QU!yb;^m<|Df$HCI9;+?f^hZY{;54wbsU?0p{Nr7*9ejvdUHYZE~>?G zT*iU({67Ez6EN6+giO>e3MxMd3?N8CIr@0b=2fmG48_o@WXQ=otfP#)$sHSi4*@l0 z+m^K$z%yZQd5!VBm#@?V5IPmgZS^JvTK=Gk3Vgl3jN^V`G4(^SAo;}8jdS3g<_&%Y zX;=A_Q&&!J$=2uBB3VKfJxH!OoDhP;+H84d5aVO%@=Y)`N;W=Ta&U;CcnZJMrHS^3 zC?V%w#_ZEGmUT@R5cZkXRM{0$z0k1;bosN{F{KNd&vr{YXM*!^OzmrYe5~k&POthq z8n@MWgbfcoaa#QqFI=m<@lD42he8L2&q}3B^n_@XfHjY_RO^i4>oE1+5fc+{_D;R+ zh9e;?^5k|Adh4RbMqO(mMh_y;Jsuk{B)&~-^2HQ?ZFSY_w<(F+WwfuWAQDL)4#2Jy-MM@6t^7PZJ~wRl1KMASEwO`Td@1i(G?0I;Lu~ZbHzM{O-ETlPh5ELE^l0J8>G>V<7KjtgTM zkSz=`jk<0u#^2s}+#iE{3K3ypal8HAY><*4QSkQk)YRV{L$^+~1&YUVUI5uDr60iE z+}pXTEiwdOekD_QIWUubDWMJBl#>o9$?B|BYnq>FOx-?Do8W{1{#rxSc>`n769?XDw=5m?y6RjmZ{?i*cu#wEoNq&^@gI}!#cD6Hz3Ql* zs+Bc6UUl&)tJ>^-BEV-8e)vqv)?^kndP=^9YZRplQBuf$|Z&AvMjzp>!%E-kwNJ?qGn9>G`k@#7sOM5wg)?b+k)y>^cK zg2+2r5Uss#OW0I;rI0Xr3_VseWOA>ISV4LO9WgpiI8HuwxB%ies>GbM&nLT>FGLI(Zxvig!0$v6W< ztOg$KmI?ltzw^vB{bIw+416#3VMl|nG61s0h(-1XQcWG?KlUWZ5O!4|>U9YVTEwS8 zjf@F;%>DS&KAkb$aIy#!t+ZF9&oN-1SK%J0I9bsnr!bh}w^|lh* zbFRb&u0JQ0RRE-X&rAt6{l4-f)U`asd&i0%miW7v%~l!GeLpS=Z7V2lWDfBza$;p^ zfFaR2p2;(tmn2T!ZX7@ncI@Bi3C>p4M&doue~*qMoz{oZqp>&x7N3*He~pctnB;X92!B;wSE}E+hs7+=)0p+AlKP z{}m|dWOJOZ)8kL*S+#m=AtDrdy-WuzsHBU=vv-+C6y$Cf6!L0gpRV2udhEh`gyj&HX0VO$}qc zz4ts(IS@wG^~%!8=^~1}vdN&KHfno;S|CGQu3mFy9&6;Y29UnNVCK2vPr9L0@Obn} z7_8?;NN1ZH8VpwS7DLJhlM0hSbZl!oW4#7lPfXA=iC9pnV2~W{BYK$d*?84Ovww-i z+!cvCrb0IhZoWbTm-2-elV>T>Kzw&m{B}iT9#kx_F$lQh@uQ%U9t~S)!2YO!fa^DJ zq5+$J`*ygRB0<{W$?NU21X<_(`}e{*cm9V3+=n?O2p$>c-Dx0{BVdy`RoLn}qqQ#} zu(kx1dEBiKG6wcHVt5+jdj|Psbs(r`VD|tL+aY9Jh zMOg5VM)VWiyOYGDzi%>%a@cw99qq}>dYOz#E5yj(oxEYH)HJVbBT(uh9eLod=!uIk zLl5u=lVn%8M`R?z%zFHec1sa z{RUe)N8ee81z8LSpYNr6AAg)lSi+5|)DMLr96jMcI}1ol&2VVz{CVzk=hhm|FI`sw z(X2cec%Q9}4V5L+n+p$yf3_E*iAD(d!)a-~eDxX08MF%M5)qI{pZq2=5)Loovj>`* z9s&+T1X9B1&%@e34HX84%ID#Dl|p$-h9TBzs~v4%x;!3NjDM0{Ef;^o2EdQOH?`j1 z)3dW+iH|T+l4rv#j!jAEoDmx{mv`jHOPX>`Y81>nXDg|xF-fyixWrAc;JS2)cro(n z{zMSi6CT>X>$8@07iNcIt+An0SA?vZCGgj=0+p@Zu$#-{^*odAyZd&F<@Ck5CsNc7 z-8AAfHGJ7+c(G00$pDRiT!a^>5D4Yvz}@wNX4esRp!&1vz^?-Krq`zbkCN?hdH zPnl2kD;fz2%x@aiCALw=%4%KM&!@kKW4HGH9a2)iG#)EolDSAu(tIp9fQX4HpmeRl zuf9O&mD}arv>nqw2M5F7ys`cHGe#jdM~-rgw*Zu!o4&~c657S;!&#r04+NsKB#WYgOH%a_+6(yoG($m36RrkU-P-#5g_wO}* z_N}&7^wd1*ZkgBsRrMWbdkjekFCr1me@ZRV!(>#RDKA<2lKkJlB>Lani5YDaJ6Cme z5Br4$`uXi6V>tKk4QF74d<%ynr1PCKsc>g({h%lF<)+L(Z|n0gE9=(>bhXKy3*PeUN7JOI2VKQyDgeQ1$r0PUBEm=7Su- z$QXr;74$YR(S=)*d<^9dX_g~@m&1U8)vO`XWYf;_G)do`l-hU*8zD@pV~Pr`N0YL$ zykqvrKnl`Ya2E!sFsiS5gzE?ATsL-?v$zGYD-;pmze|Mqzn`|B=3%FbOzFPEhhO2s zjg@f!lD>L1|Brx}*ySlR*1x2Z!)yu;9i5$3h2z)E_8Bfw+`01#ZskCycYMoG|NHQL zzKIWtAOvG*ZBenqVGp)D8xLOuS)i@}P@l*L*>lc~@Qwtt8J~x?J(wba^7;S z1$F4uscGB`+4`6j6+9V^`|XP;T|lEz#-RSR0ZcP z99MUdH+&Nea+sbKxNPK~`GFBT!M?5MQ$}GSkOIu{sA=nJQLt?z3xPjyoI-~Dfge*- zj>F%`cMv`}*(+B1AY+ba#|`$tV&bHb5cm?OZVg@JF>A8i`NNm{-=ah+&E#!-2E z^`EOw#QyKILiB&z0smXaf=kofIOXI6k3S2JxhVDDLd|nM|Gj6O^!6PErnm$$oB#3E zaL_w+NJ&Chm#pf(x!}KBAyowC2`0Dtav?tSI>{MHH7CB*y8iUv2edReGScGKd#X++ zNiz2G7Zx5uus*h9D#G7?zVzZph+t;$ak|0XiYl-s#47oFw%FZnE)0?monvJ=@|Y7(=}qh= zgl`~Xh!9MR4U7}5+AVXP@RO!{3!no_{^#GG2&Tl^v-$Fj%HfDQ2<-0i%D(UOf6pkY zmx770H`wa9M@g~69c0V<;d|HutPSpHsL59Kc5^(CTSU%aBEq;UCik^Q{sm=WvY(gOpQbBnNLlH24Y zd92c#e{;S0--qFm+`rq_|L&3hf8~qnRJXmoiI08fjtTA&)Wa56EdJh%Ef|ZO z5)N#crt?TFJHFh39zVXR`=BMU;0W+a&#%Sls8`?JEr7+9jM z|L0z^RCXH6$stw~=e}kC71c;5n-rq&#+K8^s${{RtNQy!N4y2!#qzUV<}%ghR1z;e z@R9=u6>c_;h7T#OJYFoL^OguBEPGjU!cU?iGu4-4QLqoXH~RPU5dD8%sS%2> zM+}&9;|bVvln$T#^FhK?^%5cZLLlWB4Pm<+u%vtjdLI@7{&K1QO)#DczZfDSyO=8f zg7r*Y9UV9pRr5K*<>vhFf6h%EnAA;8O{u8{0S!vTYs5d1WLmNbdSO{ZQG_wKyu4ST z`b-I74LmZ$Ya1Ke4ok*`JHS6IXx>H$Ld}Ty!V?q-1FG%WevcIvO?t^Zj zos<0sz_3;DT|P-Na;)M`Kzcyfg1@s=5LvTIG^B8;G7kiTuPo7D`~{cv2&94layE5? z>Q~po5)Dd+g};D;C<#Vx<33 zpixR@r@r0bj&O-gA5OLRl|JJEu!#L!@M=li+Kw#sn`jIJWbSiu zEZqL~WF^yqB40Fr5hJvZtRyc9Zx_7?Ds<=;P=VGkOcVlkx?=YQ6`zvw103VCA(8Pu z#5>trpagXAqy2oO9hj4B@}CqKGGM5<`0))Mew=2!`i0Pr z4k)@$ua}pq9qKiGh)^#BTN>=5nE7 z?_^341yN|(zlqT{`$Q@zx9K<1oMAbKAXMn7>^_bjR!hq5XE<(J1Nc0QZwn=F940gn zAO`$GqH>Y#L=+M^#z5u5Ln7_#z>N+NWhdFAi_A@|4?pAX6E1FriVwH8dA2FkF^Lai=*laZ+)2)Ewc zK{UzcrZMz8Dc{&2Tm zFAfa2pj+|!?H38&+$5%gzCwNK-Rf9t z1)(*!k3O{?vb4d&LKejK7tS9 zHaN+xMWoW+&ZsA<#%X65V(K_Iv%JM{7K32Us*6CyMjT`NCmY(!BG@m}Lx1D;>?oW- zTcs_!vhy%lz?M+Wd!#eh()D95l3S?I8&Ihm?2!TSKboB-2Df1@Bntj1o1M2jAH&>C zsOo}~lat}ioAVk;?3XhSeY*bT;)ePtMrIy>F#Ufr|Lq?9uYLJ?;M}=$sSk-nFUN+P zrLwHZ`W@ByYzKW9s6D`h1g?F&tFz)7;5QgddF0xs{fR}jc#Dr75ji@pf#E`5JUTs{ zHo`2ruK1BZ$QZ3$Fz?~FzMeilE$+m`HF8#m7+lVDU!&|9>m#o`3EYJ_G zY^7#rXQQt8i-pXLQJ*}Lk(0wlXFpyg!*jv&K@kzzTYT=htJ1tql@x2xL#Es?JDZ{g|+jtm-+Wo0~&;jAWXJcpoa5d+u zep0(Xxu6B`$F+Z`>$OfkAZ&1vgowD<3bu@yZ_8Lz!TEN3)!pyUuNlRiQj$TqsLI-N&Z8cH3$`C*S@95brye1Y`(cQHj*o$X z4LhHxm{^?HdC-~(grt9L_u()q6eD?<*y#R7#Fsm?Ku?NRsahs5Q+oixIxMObpJkQ8*)@FHi(T+3nZ-e!W zwSUm#wT9+(!{tWbS(wKs6H^{S*^+^C1K5ahfzMD!MmjbCf4Wnc=vaXG4^~1i%CqB9 zP7ZLu`nrSuR7UJ^XqTs&-W7m_0|XtczmwoCLx%)9xx(B&lzriLhz`ev3zezbS{_yk ze+U}OI1ipu4~!+jnoGjdvqboa~Nah_7!>T%1PV#;?`oWfW526H4J4s+k0q zkOq}Ve& zYxBN~>EBy>Sc`;c%dh7|rrolq2Cm#GC#zaw6O}nmtnP|qmnaX~D{R>dNr!TYiM=r* z;TXc6i2{g;)8wP~uzc7F-YprB!}4C^+&qMt9Jq%KH|ceL;PPWAp6MG#)!HjIas304 zD+9TXwl?fKxbnMqE)pBsdb=5Y2i3ajk0z>Vi-vtQ=DY%7lAm$*HBP?;h)K1>|ICp< zVw#n$uG3fKw!Js}{Ad&4T*LW(aUPx&WqMvBFM6EJxS0l!UE=8Lszll;B8LW$);(NN zVm@LG`!F8Y6Kx;#UdgD=L~X7AEPW>X)fk|iEs_dqLN`8H8|!y^1>z|bc`&I>r=4l! z87$*Eh2=G#PEt&124=U+WwVjgPoHX7WQt8kxLUR+AI+^oIQ*xRtgMpgXr#WqBbSLd zW6r+y-0d!(ggCQFTy-!fONGAsPw%;8P?(!#_fSx15s4Z?4*by8*4NJu^k;<~pTBdQ zIdeupAW1R2*~P^LHT1ab;)Sa?p9Ne*rVHo&ARbit3H zwKO%=fq@D>MbUhHfo0)re%sNYK-PnFNECq9Kpd4lQbe|)+yFTbvp10k!sz!msh=_W zseiau-rK9!yniwCfD}z&!l1{x>)eRvt`lE6JMBUKZxEfY1*A3dd1A72CQ+?F&*5~M zUEH<2&jQBlNG*-wg&yc9X5hzj{CAqBO3BF7MQ#Lcm+(Il)}An%qM87XX&jMVm)vgV zL0RmnIaZSHY}Y!nOmbrirr%=^6!-!_8VZ7*qH}kQPzB@TB03HakseNN+@A9U=QSQ% z>^fc_h~L4LLNiGnnbfPe4|7i=BO;PguiP>P-Dds$b9Z-;%UaS!Vcd1$0y(GyuaPVi zZ)8L|ZYM%z+MDm2o2#X+-hz299B}vk%*o1ve~G4zO)Vfj5MZZ9N8?;I+1WLa zhfWi>11k_=>L3UiS)3l8n&Q<^!Kp3cPLS+Ex@a6*QsN4)0O%P%i0@GJQ&U6+rpkS@1Azu0exUL|(CWJnc%1Zx4IGsk6|Ojx|QVgBcm>ZSl?J zn*e3$T!+d$3E`YL>&K18Wlxh-ng6{;VqM*4EqkQ170W7L-5I%7jkv28i-r-Z#$AlH z4nM-Vx(clG<^1C0Ll?lns>FaAia@lCseOM$?+v+O`pbI!IQIFg`Y^+WeRw+VsqL?3 zsrqk~rYA&LsP-%WS)M(J@)9n#U4`~FcwSq|vAu{dT{|rD&<4zY;~JOAcE08KsLSipI@9gAjuqx5Qlh@uZ1Ogtq0k0GMDmFil<5`8jfa6Hz0Z(3R z^4y+>M{>2_G@;?U@)&72zxXaoOH00fan~44^xWLWk_k2?!j?SMq9d@c>U3#oDNcX! z^_feaS6Zkp!Q+Vr0x1Zj@g%Do`h}l5PYY)f97&^ArC+{Wmy^ zCIvZph|zIg-plf9HGG|nhfc)n8c~~B#OQ?@%3i6hyio-vXsnBTD9;K^YZfLu=TRhm zk77S|OybH<*$sj%cBKw5g`3KigC3isOjos71f-{&$||{KSj%CJlKlD>1kgz_-s&iy zJ`}S(H$aU8Z^=<`C`T28-Pm!X;qVc3lb!T(#@M;B|F8gb@EivfyzZfwfUPdNB#9|$ zxVwx)TN74ZoyaA^oT!rpEpP#vPxe=Y0J38X3hZNMMx2ZmMwWhqFiw{3t~*eTg`oJQ^?BofLOB^Yhr)?ZtgG zBKZlrxqc%wUF5CvD;;=O|0T9`r#ZF#97MR6jJ;_9jqh75dHnwMWi7)v) zM3ly8(d}@YlU^_~{Z@N2p9aDVTWnEY#nzi%!UV^0bXH*!UUOtbg=sMKE0rO|CMzNrnBi*+zG|c)8 zdw1#RBbdd9u}bI^JTQmHIQW^z2W7#d#}~DgY!T&LM_enYe46oLPh+w7B~j1^Kh1*Z z606|FaTSmC$hI^_8>rvp1V`e5a_BVm8lFNnh3TJ~wEIRzEmPf9tM^AcLK2@o{pvV< z`2`%nhMd&ZV_$~{Ji9&Jm-iw`=rtxShd!JyU}c&sc`hTj824Hy&=qqP%I}ETd4IFw z3U=c=V6b9`Em^HLS})l!7{R}v%mVKrw@<6DFVYNz(dme z?!`-6TMoSe0RdPC^4eJsEyu8{?EQ`xQ4CloVLbOo3(AMl?B_8{uOo0M%e`_fbt4Vp z16+Q>ujlh|sH9q_m=F1OVpp+lEhsQ`sd`0^WvPzU3W9+f0(P$xb;SZGbrbml^ zi0uJ{`I_w1kwB|KY}=+?+2L&)Ne^^=2aC>7us%PHK0DMEm6!gICy>MMz@@&eEid2x zKG~CZiizn$mA{XVjk)%|$d>z(*0k~c+%A|39(r=OuW%F%1YhAy=~$B`@a)=%#b}3n ze1IsgxIAM!0@aP5;B=07VarEnU>$5P!S8%lM!s5-E)wJ;Q8j*VG8_qY@*Xp_r!*G( zLt3t{FO!~o;MS6&lPu{ugms~HpTzg|x7!`*P1yQyC4UYKG{Qwp#ElmGYKA zrAN|#EVj$=zzn@01lqM12rZmbs=pv73P4R@Dx=t1UVd6UY_0Q9oLK6Q#}IDzLj5vD z^g%Vw>&Fk*^A$2X>!V6e0%yz27V5Jra@}$P;U0MVNqcbJ6fYM6B+kNLP9@dCEKmcS zT*UdHCJ0hz2JcgshROX3;(=`^K7wQ4ma=l!&hAqg$*R8(-~<3rWskNI!~FWvr6u00 z!D7O~F6+y$MWPnRnugJY26wQEuGfYcxNvUs8aWL=1YFx_hbrmYx5t+H`I@3soD=H$ zinhMDt^)qXhMXNoH0Y61UtOI9OA)l0p{FhS88Yv7s?r%GsdLIn8%dl|-b_4*@as#Z zfjzefS1bIVo=2Ilzw)WWsH~r*oB$QP{~O-!IM19zFGgSES5-BDI83 z;@w1!3-oFiLCh~aa`O6H#h$kp0$vNy3mC~>yl9B{mv`@m(V>0wbzB1{+4>Xw@&!fC zvpiNndp0_7$?@b28ln-8DR_8gfBXn*xGjvzkUp9w@Lo3;HBX8#w6CO>H`n_8aWm!- zSKZaoq4-+(!l6ybX}RA21jqE763@A+|3%z7n~$I zO)+ii3ko3PCI?*I<^o7eNW2Y z&sqhzR_i_&qJW(0I=@g+DaUm4#9l?HLm|0sY-xZLr#MPgp zQ?V)86uH9U?OYrE^oa3~hrT;r;;5jCDJ`*YSb7?p_aN;P>DMftAYzDWv(h9#ISfK9J+W?wS zbtaAwNU7zQ7xXJYFcura)oED~&EP;ZpJ#73elCpXzh!wBsFTZiD$+bO*IitKn;DybOy5z$6+(EHE#W zY!+nWzR$~VQg4FCrgr*ZFhd}y%f(nYI|^hA;3b0d3dpZdkP@ZxK48V%Uwua=ClR2X z1~kgpap7CZ*fW~^Yxy?(Ae(cFg8I3mk9v=f9sx65nY;Zp@VG}dD|XvxqGxrbrG;ph zz`dgsO3^F$jX~1*G9KQYJ9ezBt$}8Xq-AlGAl*JN-|T|O3`pKct-YjV88*JwJ$;0{ z)}&wqMa8=SM4-(!Y7coa0$FQ{c1BDJv!I|LJG(Udi-U_8ULg9YI6oVxU3;o-JmjO0 z`E=ylCO^0wdbY1FwF4|spg$C*aZ6)OVjKy@G2V{oL*MuB_ z?K>VAsDhVPX5`_*pPAV1A&m_dF2Rz{Z$oOiy9xd^nZ|K$H0>!m?|PR4Z;Bh9JsRSMp#*~^%gWg2q;mB0m@ znc=VpNPl40%H$H=62IrW%0dBIEcqRyCqT?63sqd$_+D0I^ z@bvBdvGv>q`A%6l(9`g!d|nt?`xsHt@ColMjODfj2A#vC zL4)2G;xbOX{1#M!EhnrOAFd$nmzRO!c|);|+x@)|awQ#y#UpzH+(95gvsE#0Aja__9fqGqA%9 zAcyB5E*7k8Rk&XIwSgAd49K^Nq8!arax;mczx-K+Ip_uTg# z|)=bV0WsCxbF&OXE` z%_um2W~HYGlqd1+qHvL_cKW6IdT-%k8wcl8H!8|7V5iAhs5q@*Ro9+Y0S>WjS8H1F zS#{muy$YsreK4)$@UAO}jLRlWn$#7nNmgvIFR>bjYUa137dlRAYunglZ??&um>Kfs zGt2Fk6=3F9{%8c@ql{TqU*911hPev~O00DSv=K+{2xBT0HFxBNv)oS5fQ&^{c`N*% z8ym$Ea)l}RrD#lxFyck(H@x||HJt`NUyzSncv#+(bj51{2?ZF*Rdx|?-~L`H>cj87 zt5Kgw=(=jo+L~c9C_3%X_@MmAghA5|r_7&YKgeI$1A3@47sjK&&fTx&7aJdc_>B6D z&G*ROr`v^X#%9n*8Y7g$uq%5Bj<{%ydgGO*Q4ay|wx(mGq$FfIVMB!HFI#t^b+aR4 zq6E^-yC0aI{b>5#0c=8fO+Jw`S-0v`3j{)xFVROe_o}0$nnx>OaAL{AvhastnNsDr3`!p zRDZRmp)WURQS_0&JJK;@gLfIy(Iu8rl zM4?pKZ1qedx$@g0ntGUD7$w83?r@H5CPj@*qCRajm9K_eeZ=NFh*MeashX|_0@1y_vjk6L@Y2c;IwpcP zjN%~W>T)JSLFqW~B58Pd*tpetr#^k3xOnmWPgl-+C~I|m>08-;aC~-&F@JlvKI5h< zPA&yuL!(hyV*O;2PBPP~x@)Xv3|K38K9zC+uCYO%jR1RKG~#Y$rbBs z`!ii&%^HxIoBM)D_Ew(VY)q{#4B`NJcybw;f?+UTbRHwGmS0$Cpqg>Mkn;<`CZAZA zcmKeak76ic#9fmjf5PYmA(oA*MS^}twfomEQ}-`wotc|vneWDiYS7=p!$|%&W3CI{ zA9)xz%^0x4_m>YZ#u-^<9_dZ0VZiY}Q9nF0$by(Fb)Q?>wkR~iYd|_`l+oVQ_zK+3px(YvLA5 z+SaBC{-lDOoJz$vP%33)=<1WVd}4!x&ovuvIdVD(Y0C~9Y>^ZQ_8Jd@r_e>aSigPa z{@Sj6N8kYH4svR?*ZkUGwdoe>efU?(*Zjdr9&`)=snBof)%S6)gqaf;6&8|R72(7c zrX;PBu2QHH$j*h$v7yE0(gtT|zL@iMz68R;8+=9sOzwofPl&wQG?S_+WAcM08H>gB zh6Or@iK4V#fft7p8_2M~kn(1CUF(b3H4fhSism+FEU%d{cKO6NwbfHyVwdyV&# zyx6E!GZ`|6VIRFO`ApD_R=GfscNT;yWbIp?ev!{=FG0oFRB~_fx1Q>N6ZYVO$5#y1 zzWP0$i$l!~Zyb$tC%LHRgidzvxEvHm-$|p|$I4vju$VN+``r3kOZ25(I=_HEGa!r} zT%qHaFPt?Bd8Z^I6EWp(B^nYtT6@Z8&ztNzoJ9ypb;h$gPPlwuIkD5EE*`)7UXd=f zLB;uJgTc(wQoDZj49Kyu(J^8or$M`pcn7DGCWc3;AL_40RBE<0FKGA=k18CcrL}`? z#iF%O5B)TddxDj=;GHsrA0N3yqGi`)-he?i_7bd)oX=i?m?`;!{66({3$nDM>%pGG<~!K2P<)sD@;suB19h1SHP&V zinw*DsHu5%Q(Gf73wIs*>OsF*AWCyWlAXP;kxT8B;-5=728TnOJgUD2GD}I{;#Dhp zD%X3YsyEx>9<|;kvSOn5DHP;tXAH?lE?%#dA1zQzRFyK1gQQhSfrXJ@6IegImSb-* z2X%wRW7}8ASNip9$a+?8E~DUBoRs&WLp(R@Q~;5nQi|!1%3hB?wa!KT8J2@f*sVaY z7U*6^!ed=Ug~@cE@tIK?e|K|tuP#7a6814UEKCd4zij1$ z4bl;}E%e%u9mPcc2>J7e(3_h$8?OU?*h#@K3A{3StRn*}^=s=MIRvzA-@bkHb>WQy zz2<|a8u-!5m(54E&=AXVpDmf%rU4)bk(_ZO=+zU|6N9q%`=q_b`B`&KAWcx#;m>5W z_$8UHTOfZ56ud4EDMf2$4#z8sLPZvt%h& z^^5XVs|X9#YZ2Apx9NV@w-&uAvzcazQ78{h6=12W?#I|hY~Ej-iUnf!gPD46bM1TU z@8_o}Z^+&-8U#N;l^2pf`}U{&__&1HMSQ8}e&#ee?a4=uW^)rLTb|mE9PGr<8YXxn zuVO}`SPjrc@RS)z+D_|tT^D;6 zX|q_x@L-!YwC;7YDR&hWYf;$8wGzg|quhCD;SkInZXSV0POf{PWNRZWdmb7N7>A|& z`7#R?H~G=ClJ!rjmqD;?meu6T?8qGTM}$MAXAk&8Y2vin@BX+j*R`V@;mWsQF|t&d z{>bsjz*Ucl_YhPRoDHBRMZYJK)~tu@9S&lv%?eLh$pcdnUY;7Gus|3@h&P5pRj;c8^rm`{t_$EAPX?1X~mjMSHJ#$wZBOt=YK~24}@-qqy0+X>uE#pi= zRi49<|Jo2kZ0EI|3StV%#ZD^?Pj_x?e2xI#f=cirdET7y+MoSeT0)6r=gxI!XD@(; zMPT0Ph8w3H7O@^l)fK`tG9J7<(R2m|*=iBXzV-KK(Fb%E+TVXhHcCAbPu+_Pnj0ccvZEa(-0O2gVF7MQducoZIIhmOb%L-Ak zc5L#&0Yj#5O2m~d7GEFcj87>~Kc{ONRENz8O{4u?DT}B#f#sDM?r|q6BgR}8f?{PS z+SA=KP2|67oOh&0BLdMx4uk5RW79=?<6IRK%>E9QuQs={Q3P$ZKJR)-l{mk=?9~6g zDOrneh2_-!ABu}{lV|!}3J~?M^;-B|X>Ttf-{8E}z`)A<0g$^8ov6u3_xtBhA=Lcf zc3k^pC5}+t;zB5pvu-&b%W|Es6B;k#%It=0Njj9JvpRV2Fet-w(R^93hvjK}U(;bFFYQ5WAMl2z~0n~ zadW(pZIk45^IvrUr)U!H6JnH-Uy9;{WbVtWT!(XD7>}zY@5&2XK1X@VleiQ zQ{Lk6ZN<@%HiqKlccOxv`YvnRD^nxy-|XlLla6>@@w;)*Uc@}|VeyM@6B8qT>(>%z zM7m}8qILbU4!c-2uj+lg8$P#xuCM#Pcfwr4b5T+3w!ZYI*H_?nb9 zFbHPvd~PIWc03Jsmy=+2uBYiW1iiX@N61AQ)1(B*@1$B#FOjY92Zu2klu_4}Q8mYX zh;TSev0~#Bqj;roX@Z7_yabdaE~R}{HnH2*NyOqW(T}UP0yTSZ?;f_dIY3(0lWn{5 zNcZm5&b}RZmZz!`h;^%ECYmh-Ttcm;)!!_}eKz^&E06;h>v^QwyO+>PU}@9xWc94C zxSm(LW}V;ISOnxq%|Kd4=8h|+Qk3}A@6Ct1it>8D#ZBB_D*U5*e)u~hM)0Jhi%CG4 zfKh^-nb1I`mZ;+&WVf{{hjjSpg?m9 z2qsWcI*48lT4u4U@7y;J7HsLmr|7*)N&V?N;;>2P_|<^ZlNvW8`xrqOwGtZrZY$XZy#pT&hpLL> z&rOb_iBE-%+2-aZh(@4}-}(N36?NtDP_Av**YcIp=~!Y?6yc1T6rr3*QPv`pr6Hp- z6xpRh(ov}+%vk4WMaWuN(}ktMoMU^C z0$?>D&4<$<6l5J^pwzwpFf9YNwDocf+c`xu2^^c;ega%@n&|SBU8=kYEodAUykK?PELD( zU0EeB$oV-DyMGe3@woF0w>Pjf zlIn~LicD%4{`o>j3VnQi51cn}!E8hPNpsa_XzVbOkzj0Uu?I0`+11}Pe1Hc&rgzE7 z$tk;sgvnce?(N+WFge^Pq01<=5cl4W(rD~u)b((uoQ_i-(EZ|FBjRgSn_{Eqcb(Wv z!GVE~2#iE`7&d#ouRfdi!A&tVe@*kd6_S!YpFV*nZx$Zv>uvf`R@Ij214JJtyyb0| zdNX4A&-mbZ<7X``{%>-ZbGlJk6DDMcQ7-{Vy3;RX8Fa%)D?Zc^WZ`<-++=>s*r%c1 znZ@C-Vy-t*J#!rBwVdYhk^j6hmQa;TA^!XWE#rdY`g(ehp87(DdPadrBti7E|Spq5Xa zw!7+AP!1sxD0Enfu%HzNB@h#XXf>uEG;Xh}?(m^w6mafo?ntl1^2@=0#?P<7)??|? zrNxATh`zo)lqTU9FDj|1)H!IROO=7ODbRsd5^iG5iANsEn)_VxRaI-b_g?gFqj=fa zgZb#{svyq?ua4l(?I@kR5-^0;jtLRq*nqgItDR8C57CS9F>yyv6r1qNX-S$z3+Qx86T~63$8m87Pzh7dj=TWHSXW_%Qw0cpy*8GA-Jj+wIlzd43%e_~5lAa6dYf`04X!8FBFxttOWomn3|s zc)E@D)6Vke@Zu=g*y6)mmZMjFvt`(@IZxJxtWQ>evL<3sUOj88YWCDJ_B&aGiFugg z6Ge683)TrUouGRAdT-G_uX?*trLw3mwGfS$V*Fa0?A}xP#|${BIN3z+qcmE4yZS}e zk^rvoXoQcu;6R*r)Wp8C_If2ecT6sdKljv<70yW|-nf%!TcoK`RaFHuC!ycbq9#9d zGw6g=Da$X2#U<~OQ(bo0?S`=tm5~8|mkNcL%c}^lg(9oUEoeo7vxGG&U zRi2%%)j1b!ju9gB?1idvTJv0poI_<5tlG^$%0ylNilG zBH!0myUTSZqHDoOaXq{8KXWDhu9LP(45DeJ)i9otA6&WO|HvjR65wkP`g7&rSlbz- zk=5mXYRh5-oQ!UicgbA4|#&+FiT&ftx<9b+BYR<|#%?LV({f}92ba09C} z52siE{Vb2G3&LIwy=Bo$t=^3%Z=wric0$R4sXH8fj)krpzwaHlOQD5O^QOKH$%y+> z*XIEkMhRtu4P&^dr$n~vh_E|lZmL#RqB$BWEYo$Hft#4l5Jf^l0%t}isybmaD5FKB zH14U!0cI`BfG%+ZriY-iTO}MX{J68pLA9Wcw5>uT+xe~ov zC-oMKNlU|y1FuPqU!^#Q!9NKh*%3cAM~VLgw6dS!HW@*`=xa}Wz;2i(lu^T(nVH(b z9UQ9h)$rskquAS%D5K>hCRhv6sCR6 zoW>o^nsnFrj#}x)o7?T=&LQ*!950fT-`DtIw}h5 z{F+!!y*@@Ox=kl_OJ-iBRN)UnF8GjE3Jq2Ea^(S3(qQ0_IjPtq@Q>eI^Pp14tL#W| zZ>hiQk5|GeG-pJtefz}S^cM0-iLGsGATm6N-$j9J&ZZqZ_M2$5cKXQnQzebH`SM~9 zf3FtEoX_<_Wv;Pyq^-zpDC>F#V8n+In2kG-{^+U71+6b)xdb!FM*!flxm-K@8u%1& zvTe#LL#_abKG7Va>#w4_dGpTK0SZvgW;jME_VR%Ii}fa`u!8P}2gyVh@mojOoU!2= z7DHk4=2uUj3R_D#Z)fL$FJJim{nrNM8Ay0{69p|!Z7+xNf^;CGC`i%_xI25;HV&f1 zyBD;jm`QW6)MR|=E9*FghD z3j>FgDfyeSGM?XH{T6`i4onscct~~?dpDD_vz9gewDZLailV5uxA%A+pU)$UWqn7F zzYKY9*t8^m=byP_EYFh{_qDibB-;(k5RD}30?q_fmz)t+<>yi+^H_k;V<@M51^xebO6R;jy1 zXB>UeHv?S5h;YKpA#H|_lJV$Dii3kNc1<;#Z@J6ey+6-^KK+6Er<|ZUY&wfG_#~JR zD`rO680=_m9nTsvO?00;<`ia7PNhZ5HPvHrG(>HP7z4_WZk0Kmx)zWdHM z%W^i=tVzu`d$utpu*P#>)Yx!#wP~$?u-bJL&0p+B?X1J>XGX|Xqmn9*3P+kB&J#%% qnZ=C%+?@O!A`$E1zrreYzR39Aqf%SUl@{TOi0K}S-S-R*hy4v*@D3>e literal 0 HcmV?d00001 diff --git a/static/images/docs/platform/env-variables.png b/static/images/docs/platform/env-variables.png new file mode 100644 index 0000000000000000000000000000000000000000..cf4e6d5acce0493ab38d7603f85c5a1f2df278e0 GIT binary patch literal 109968 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
  • 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 literal 0 HcmV?d00001 From eb037e3bc767782d29e4154bada14ca1754a3686 Mon Sep 17 00:00:00 2001 From: Atharva Deosthale Date: Tue, 28 Apr 2026 00:00:25 +0530 Subject: [PATCH 3/3] fix ids --- .../announcing-variables-api/+page.markdoc | 34 ++++++++++-------- .../environment-variables/+page.markdoc | 36 ++++++++++--------- 2 files changed, 40 insertions(+), 30 deletions(-) diff --git a/src/routes/blog/post/announcing-variables-api/+page.markdoc b/src/routes/blog/post/announcing-variables-api/+page.markdoc index 1b15cfba10..0ffba96002 100644 --- a/src/routes/blog/post/announcing-variables-api/+page.markdoc +++ b/src/routes/blog/post/announcing-variables-api/+page.markdoc @@ -51,7 +51,7 @@ The new `Project` service exposes `createVariable` for shared configuration: {% multicode %} ```server-nodejs -import { Client, Project } from 'node-appwrite'; +import { Client, Project, ID } from 'node-appwrite'; const client = new Client() .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint @@ -61,14 +61,14 @@ const client = new Client() const project = new Project(client); const result = await project.createVariable({ - variableId: '', + variableId: ID.unique(), key: 'STRIPE_KEY', value: 'sk_live_...', secret: true // optional }); ``` ```server-deno -import { Client, Project } from "npm:node-appwrite"; +import { Client, Project, ID } from "npm:node-appwrite"; const client = new Client() .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint @@ -78,7 +78,7 @@ const client = new Client() const project = new Project(client); const result = await project.createVariable({ - variableId: '', + variableId: ID.unique(), key: 'STRIPE_KEY', value: 'sk_live_...', secret: true // optional @@ -88,6 +88,7 @@ const result = await project.createVariable({ createVariable( - variableId: '', + variableId: ID::unique(), key: 'STRIPE_KEY', value: 'sk_live_...', secret: true // optional @@ -106,6 +107,7 @@ $result = $project->createVariable( ``` ```server-python from appwrite.client import Client +from appwrite.id import ID from appwrite.services.project import Project from appwrite.models import Variable @@ -117,7 +119,7 @@ client.set_key('') # Your API key project = Project(client) result: Variable = project.create_variable( - variable_id = '', + variable_id = ID.unique(), key = 'STRIPE_KEY', value = 'sk_live_...', secret = True # optional @@ -138,7 +140,7 @@ client = Client.new project = Project.new(client) result = project.create_variable( - variable_id: '', + variable_id: ID.unique(), key: 'STRIPE_KEY', value: 'sk_live_...', secret: true # optional @@ -157,7 +159,7 @@ Client client = new Client() Project project = new Project(client); Variable result = await project.CreateVariable( - variableId: "", + variableId: ID.Unique(), key: "STRIPE_KEY", value: "sk_live_...", secret: true // optional @@ -174,7 +176,7 @@ Client client = Client() Project project = Project(client); Variable result = await project.createVariable( - variableId: '', + variableId: ID.unique(), key: 'STRIPE_KEY', value: 'sk_live_...', secret: true, // (optional) @@ -182,6 +184,7 @@ Variable result = await project.createVariable( ``` ```server-kotlin import io.appwrite.Client +import io.appwrite.ID import io.appwrite.coroutines.CoroutineCallback import io.appwrite.services.Project @@ -193,7 +196,7 @@ val client = Client() val project = Project(client) val response = project.createVariable( - variableId = "", + variableId = ID.unique(), key = "STRIPE_KEY", value = "sk_live_...", secret = true // optional @@ -201,6 +204,7 @@ val response = project.createVariable( ``` ```server-java import io.appwrite.Client; +import io.appwrite.ID; import io.appwrite.coroutines.CoroutineCallback; import io.appwrite.services.Project; @@ -212,7 +216,7 @@ Client client = new Client() Project project = new Project(client); project.createVariable( - "", // variableId + ID.unique(), // variableId "STRIPE_KEY", // key "sk_live_...", // value true, // secret (optional) @@ -237,7 +241,7 @@ let client = Client() let project = Project(client) let variable = try await project.createVariable( - variableId: "", + variableId: ID.unique(), key: "STRIPE_KEY", value: "sk_live_...", secret: true // optional @@ -249,6 +253,7 @@ package main import ( "fmt" "github.com/appwrite/sdk-for-go/appwrite" + "github.com/appwrite/sdk-for-go/id" ) client := appwrite.NewClient( @@ -260,7 +265,7 @@ client := appwrite.NewClient( project := appwrite.NewProject(client) response, error := project.CreateVariable( - "", + id.Unique(), "STRIPE_KEY", "sk_live_...", appwrite.WithCreateVariableSecret(true), @@ -268,6 +273,7 @@ response, error := project.CreateVariable( ``` ```server-rust use appwrite::Client; +use appwrite::id::ID; use appwrite::services::Project; #[tokio::main] @@ -280,7 +286,7 @@ async fn main() -> Result<(), Box> { let project = Project::new(&client); let result = project.create_variable( - "", + &ID::unique(), "STRIPE_KEY", "sk_live_...", Some(true) // optional diff --git a/src/routes/docs/advanced/platform/environment-variables/+page.markdoc b/src/routes/docs/advanced/platform/environment-variables/+page.markdoc index 5c6a78626f..dcfbee2042 100644 --- a/src/routes/docs/advanced/platform/environment-variables/+page.markdoc +++ b/src/routes/docs/advanced/platform/environment-variables/+page.markdoc @@ -56,11 +56,9 @@ You can also manage project variables programmatically using a [Server SDK](/doc ## Create a variable {% #create-variable %} -Project variables require a caller-supplied `variableId`. Pass `ID.unique()` to let the SDK generate one, or provide a custom value (max 36 characters; allowed characters: `a-z A-Z 0-9 . - _`; cannot start with a special character). Function and site variables do not accept a `variableId` — Appwrite assigns one automatically. - {% multicode %} ```server-nodejs -import { Client, Project } from 'node-appwrite'; +import { Client, Project, ID } from 'node-appwrite'; const client = new Client() .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint @@ -70,14 +68,14 @@ const client = new Client() const project = new Project(client); const result = await project.createVariable({ - variableId: '', + variableId: ID.unique(), key: '', value: '', secret: false // optional }); ``` ```server-deno -import { Client, Project } from "npm:node-appwrite"; +import { Client, Project, ID } from "npm:node-appwrite"; const client = new Client() .setEndpoint('https://.cloud.appwrite.io/v1') // Your API Endpoint @@ -87,7 +85,7 @@ const client = new Client() const project = new Project(client); const result = await project.createVariable({ - variableId: '', + variableId: ID.unique(), key: '', value: '', secret: false // optional @@ -97,6 +95,7 @@ const result = await project.createVariable({ createVariable( - variableId: '', + variableId: ID::unique(), key: '', value: '', secret: false // optional @@ -115,6 +114,7 @@ $result = $project->createVariable( ``` ```server-python from appwrite.client import Client +from appwrite.id import ID from appwrite.services.project import Project from appwrite.models import Variable @@ -126,7 +126,7 @@ client.set_key('') # Your API key project = Project(client) result: Variable = project.create_variable( - variable_id = '', + variable_id = ID.unique(), key = '', value = '', secret = False # optional @@ -147,7 +147,7 @@ client = Client.new project = Project.new(client) result = project.create_variable( - variable_id: '', + variable_id: ID.unique(), key: '', value: '', secret: false # optional @@ -166,7 +166,7 @@ Client client = new Client() Project project = new Project(client); Variable result = await project.CreateVariable( - variableId: "", + variableId: ID.Unique(), key: "", value: "", secret: false // optional @@ -183,7 +183,7 @@ Client client = Client() Project project = Project(client); Variable result = await project.createVariable( - variableId: '', + variableId: ID.unique(), key: '', value: '', secret: false, // (optional) @@ -191,6 +191,7 @@ Variable result = await project.createVariable( ``` ```server-kotlin import io.appwrite.Client +import io.appwrite.ID import io.appwrite.coroutines.CoroutineCallback import io.appwrite.services.Project @@ -202,7 +203,7 @@ val client = Client() val project = Project(client) val response = project.createVariable( - variableId = "", + variableId = ID.unique(), key = "", value = "", secret = false // optional @@ -210,6 +211,7 @@ val response = project.createVariable( ``` ```server-java import io.appwrite.Client; +import io.appwrite.ID; import io.appwrite.coroutines.CoroutineCallback; import io.appwrite.services.Project; @@ -221,7 +223,7 @@ Client client = new Client() Project project = new Project(client); project.createVariable( - "", // variableId + ID.unique(), // variableId "", // key "", // value false, // secret (optional) @@ -246,7 +248,7 @@ let client = Client() let project = Project(client) let variable = try await project.createVariable( - variableId: "", + variableId: ID.unique(), key: "", value: "", secret: false // optional @@ -258,6 +260,7 @@ package main import ( "fmt" "github.com/appwrite/sdk-for-go/appwrite" + "github.com/appwrite/sdk-for-go/id" ) client := appwrite.NewClient( @@ -269,7 +272,7 @@ client := appwrite.NewClient( project := appwrite.NewProject(client) response, error := project.CreateVariable( - "", + id.Unique(), "", "", appwrite.WithCreateVariableSecret(false), @@ -277,6 +280,7 @@ response, error := project.CreateVariable( ``` ```server-rust use appwrite::Client; +use appwrite::id::ID; use appwrite::services::Project; #[tokio::main] @@ -289,7 +293,7 @@ async fn main() -> Result<(), Box> { let project = Project::new(&client); let result = project.create_variable( - "", + &ID::unique(), "", "", Some(false) // optional